diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json
index 37132a2f2..6344b2ba2 100644
--- a/.vscode/c_cpp_properties.json
+++ b/.vscode/c_cpp_properties.json
@@ -15,6 +15,8 @@
                 "${workspaceFolder}/include/inline",
                 "${workspaceFolder}/src/dolphin/include",
                 "${workspaceFolder}/src/dolphin/src",
+                "${workspaceFolder}/src/bink/include",
+                "${workspaceFolder}/src/bink/src",
                 "${workspaceFolder}/include/rwsdk",
                 "${workspaceFolder}/src/SB/Core/gc",
                 "${workspaceFolder}/src/SB/Core/x",
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 95c0114af..8b20ba481 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -55,7 +55,18 @@
     "gxget.h": "c",
     "gxverify.h": "c",
     "card.h": "c",
-    "__start.h": "c"
+    "__start.h": "c",
+    "binkread.h": "c",
+    "ngcrad3d.h": "c",
+    "osalarm.h": "c",
+    "ostime.h": "c",
+    "bink.h": "c",
+    "binkngc.h": "c",
+    "radbase.h": "c",
+    "oscontext.h": "c",
+    "radcb.h": "c",
+    "popmal.h": "c",
+    "osalloc.h": "c"
   },
   // Disable C/C++ IntelliSense, use clangd instead
   "C_Cpp.intelliSenseEngine": "default",
diff --git a/configure.py b/configure.py
index 8dd1206bb..bbd822360 100644
--- a/configure.py
+++ b/configure.py
@@ -215,6 +215,8 @@
     "-i src/PowerPC_EABI_Support/include",
     "-i src/dolphin/include",
     "-i src/dolphin/src",
+    "-i src/bink/include",
+    "-i src/bink/src",
     "-i src",
     f"-i build/{config.version}/include",
     f"-DBUILD_VERSION={version_num}",
@@ -272,7 +274,7 @@
 
 # Bink was compiled with ProDG
 cflags_bink = [
-    "-O3",
+    "-O2",
     "-mcpu=750",
     "-fno-exceptions",
     "-Wno-inline",
@@ -317,7 +319,6 @@
     '-pragma "cpp_extensions on"',
     "-inline off",
     "-gccinc",
-    "-i include/bink",
     "-i include/inline",
     "-i include/rwsdk",
     "-i src/SB/Core/gc",
@@ -440,9 +441,9 @@ def MatchingFor(*versions):
             Object(NonMatching, "SB/Core/x/xMath3.cpp"),
             Object(NonMatching, "SB/Core/x/xMemMgr.cpp"),
             Object(NonMatching, "SB/Core/x/xModel.cpp"),
-            Object(NonMatching, "SB/Core/x/xMorph.cpp"),
+            Object(Matching, "SB/Core/x/xMorph.cpp"),
             Object(Equivalent, "SB/Core/x/xMovePoint.cpp"),
-            Object(NonMatching, "SB/Core/x/xordarray.cpp"),
+            Object(Matching, "SB/Core/x/xordarray.cpp"),
             Object(NonMatching, "SB/Core/x/xPad.cpp"),
             Object(NonMatching, "SB/Core/x/xPar.cpp"),
             Object(NonMatching, "SB/Core/x/xParCmd.cpp"),
diff --git a/include/bink/bink.h b/include/bink/bink.h
deleted file mode 100644
index 4762aafac..000000000
--- a/include/bink/bink.h
+++ /dev/null
@@ -1,82 +0,0 @@
-#ifndef __BINK_H__
-#define __BINK_H__
-
-#include <PowerPC_EABI_Support\MSL_C\MSL_Common\size_t.h>
-
-#define BINKSURFACE8P 0
-#define BINKSURFACE24 1
-#define BINKSURFACE24R 2
-#define BINKSURFACE32 3
-#define BINKSURFACE32R 4
-#define BINKSURFACE32A 5
-#define BINKSURFACE32RA 6
-#define BINKSURFACE4444 7
-#define BINKSURFACE5551 8
-#define BINKSURFACE555 9
-#define BINKSURFACE565 10
-#define BINKSURFACE655 11
-#define BINKSURFACE664 12
-#define BINKSURFACEYUY2 13
-#define BINKSURFACEUYVY 14
-#define BINKSURFACEYV12 15
-#define BINKSURFACEMASK 15
-
-struct BINK
-{
-    // Do the members really need to be defined?
-    U32 unk_0;
-    U32 unk_4;
-    U32 unk_8;
-    U32 unk_c;
-    U32 unk_10;
-    U32 unk_14;
-    U32 unk_18;
-    U32 unk_1c;
-    U8 unk_20[0xd0];
-    S32 unk_f0;
-};
-
-typedef struct BINK* HBINK;
-
-struct RAD3DIMAGE
-{
-    int a;
-    int b;
-    unsigned int c;
-    int d;
-    int e;
-    void* f;
-    int g;
-    int h;
-};
-
-typedef struct RAD3DIMAGE* HRAD3DIMAGE;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern int BinkDoFrame(HBINK bnk);
-extern int BinkCopyToBuffer(HBINK bnk, void* dest, int destpitch, unsigned int destheight,
-                            unsigned int destx, unsigned int desty, unsigned int flags);
-extern int Lock_RAD_3D_image(HRAD3DIMAGE rad_image, void* out_pixel_buffer,
-                             unsigned int* out_buffer_pitch, unsigned int* arg3);
-extern void Unlock_RAD_3D_image(HRAD3DIMAGE rad_image);
-extern void Blit_RAD_3D_image(HRAD3DIMAGE Image, float, float, float, float, float);
-extern void RADSetAudioMemory(void* (*malloc)(size_t), void (*free)(void*));
-extern void RADSetMemory(void* (*malloc)(size_t), void (*free)(void*));
-extern HBINK BinkOpen(const char* fname, void*);
-extern void BinkGetError();
-extern void BinkSetVolume(HBINK bink, unsigned int, int volume);
-extern HRAD3DIMAGE Open_RAD_3D_image(HBINK bink, unsigned int, unsigned int, unsigned int);
-extern void Close_RAD_3D_image(HRAD3DIMAGE rad_image);
-extern void BinkGoto(HBINK bink, int frame, unsigned int);
-extern int BinkWait(HBINK bink);
-extern void BinkNextFrame(HBINK bink);
-extern void BinkClose(HBINK bink);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/include/types.h b/include/types.h
index 84a3b6ec0..b10a917e1 100644
--- a/include/types.h
+++ b/include/types.h
@@ -92,4 +92,4 @@ typedef wchar_t wint_t;
 
 #define UINT32_MAX 0xffffffff
 
-#endif // !TYPES_H
\ No newline at end of file
+#endif // !TYPES_H
diff --git a/src/SB/Core/gc/iFMV.cpp b/src/SB/Core/gc/iFMV.cpp
index f1b085849..9838215ab 100644
--- a/src/SB/Core/gc/iFMV.cpp
+++ b/src/SB/Core/gc/iFMV.cpp
@@ -12,8 +12,7 @@
 
 #include "zGlobals.h"
 
-#include <types.h>
-#include <dolphin.h>
+// #include <dolphin.h>
 
 // FIXME: These should be in a RW header somewhere
 extern GXRenderModeObj* _RwDlRenderMode;
@@ -97,7 +96,7 @@ void Decompress_frame(HBINK bnk, HRAD3DIMAGE rad_image, long flags)
         mask = mask >> 0x1f;
         mask = mask & 0x80000000;
         mask |= Bink_surface_type[result.unk_8];
-        result.unk_0 = BinkCopyToBuffer(bnk, pixels, result.unk_c, bnk->unk_4, NULL, NULL, mask);
+        result.unk_0 = BinkCopyToBuffer(bnk, pixels, result.unk_c, bnk->Height, NULL, NULL, mask);
         Unlock_RAD_3D_image(rad_image);
     }
 }
@@ -168,8 +167,8 @@ static void Show_frame()
     RwCameraClear(cam, &color, rwCAMERACLEARIMAGE);
 
     RwCameraBeginUpdate(cam);
-    Width_scale = 640 / Bink->unk_0;
-    Height_scale = 480 / Bink->unk_4;
+    Width_scale = 640 / Bink->Width;
+    Height_scale = 480 / Bink->Height;
     xDrawLine2D_LocaliFMVVersion(0.0f, 0.0f, 0.0f, 0.0f);
     DrawFrame(0.0f, 0.0f, Width_scale, Height_scale);
     RwCameraEndUpdate(cam);
@@ -190,7 +189,7 @@ static void aramfree(void* mem)
     ARFree(&vol);
 }
 
-static void PlayFMV(char* fname, u32 buttons, F32 time)
+static void PlayFMV(char* fname, size_t buttons, F32 time)
 {
     GXCullMode cull_mode;
     GXGetCullMode(&cull_mode);
@@ -242,9 +241,9 @@ static void PlayFMV(char* fname, u32 buttons, F32 time)
 
     if (Bink != NULL)
     {
-        if (Bink->unk_f0 != 0)
+        if (Bink->Width != 0)
         {
-            for (ip = 0; ip <= Bink->unk_f0; ++ip)
+            for (ip = 0; ip <= Bink->Width; ++ip)
             {
                 vol = gSnd.categoryVolFader[SND_CAT_CUTSCENE];
                 vol = vol * vol;
@@ -253,7 +252,7 @@ static void PlayFMV(char* fname, u32 buttons, F32 time)
             }
         }
 
-        Image = Open_RAD_3D_image(NULL, Bink->unk_0, Bink->unk_4, fuckingSurfaceType);
+        Image = Open_RAD_3D_image(NULL, Bink->Width, Bink->Height, fuckingSurfaceType);
         if (Image != NULL)
         {
             if (frame_num != 0)
@@ -280,19 +279,19 @@ static void PlayFMV(char* fname, u32 buttons, F32 time)
                 }
                 xPadUpdate(globals.currentActivePad, 0.0f);
 
-                F32 t = (float)Bink->unk_c / (Bink->unk_14 / Bink->unk_18);
+                F32 t = (float)Bink->FrameNum / (Bink->FrameRate / Bink->FrameRateDiv);
                 if (buttons && t >= time && globals.pad0->pressed & buttons)
                 {
                     frame_num = -1;
                     goto superbreak;
                 }
-            } while (Bink->unk_c < Bink->unk_8 - 1);
+            } while (Bink->FrameNum < Bink->Frames - 1);
             frame_num = -1;
         }
     superbreak:
         if (frame_num != -1)
         {
-            frame_num = Bink->unk_c;
+            frame_num = Bink->FrameNum;
         }
         Close_RAD_3D_image(Image);
         Image = NULL;
diff --git a/src/SB/Core/gc/iFMV.h b/src/SB/Core/gc/iFMV.h
index 57b28f7f3..e2e57bf4b 100644
--- a/src/SB/Core/gc/iFMV.h
+++ b/src/SB/Core/gc/iFMV.h
@@ -3,6 +3,7 @@
 
 #include <types.h>
 #include <bink.h>
+#include <rad3d.h>
 #include <PowerPC_EABI_Support\MSL_C\MSL_Common\size_t.h>
 
 #ifdef __cplusplus
diff --git a/src/SB/Core/gc/ngcrad3d.c b/src/SB/Core/gc/ngcrad3d.c
index 055b44e81..b891c4d23 100644
--- a/src/SB/Core/gc/ngcrad3d.c
+++ b/src/SB/Core/gc/ngcrad3d.c
@@ -2,6 +2,7 @@
 
 #include <dolphin/gx.h>
 #include "iFMV.h"
+#include <bink/include/rad3d.h>
 
 static int D3D_surface_type[5];
 static unsigned int Pixel_info[5];
@@ -30,6 +31,22 @@ static void Setup_surface_array()
     Built_tables = 1;
 }
 
+// TODO:
+// Defining this struct locally because i believe this isnt 100% right. Or if it is right why isnt this in the bink.h or other headers?
+// inestigate this
+
+struct RAD3DIMAGE
+{
+    int a;
+    int b;
+    unsigned int c;
+    int d;
+    int e;
+    void* f;
+    int g;
+    int h;
+};
+
 void Close_RAD_3D_image(struct RAD3DIMAGE* image)
 {
     if (image != 0)
@@ -43,8 +60,8 @@ void Close_RAD_3D_image(struct RAD3DIMAGE* image)
     }
 }
 
-int Lock_RAD_3D_image(HRAD3DIMAGE rad_image, void* out_pixel_buffer, unsigned int* out_buffer_pitch,
-                      unsigned int* arg3)
+S32 Lock_RAD_3D_image(HRAD3DIMAGE rad_image, void* out_pixel_buffer, U32* out_buffer_pitch,
+                      U32* arg3)
 {
     if (rad_image == 0)
     {
diff --git a/src/SB/Core/x/xFX.cpp b/src/SB/Core/x/xFX.cpp
index 7c125b408..9da94b8f6 100644
--- a/src/SB/Core/x/xFX.cpp
+++ b/src/SB/Core/x/xFX.cpp
@@ -686,9 +686,10 @@ void xFXStreakUpdate(U32 id, const xVec3* a, const xVec3* b)
     xFXStreak* s;
 }
 
-U32 xFXStreakStart(F32 frequency, F32 alphaFadeRate, F32 alphaStart, U32 textureID, const iColor_tag* edge_a, const iColor_tag* edge_b, S32 taper)
+U32 xFXStreakStart(F32 frequency, F32 alphaFadeRate, F32 alphaStart, U32 textureID,
+                   const iColor_tag* edge_a, const iColor_tag* edge_b, S32 taper)
 {
-    for (U32 i = 0; i < 10; i++) 
+    for (U32 i = 0; i < 10; i++)
     {
         if (sStreakList[i].flags == 0x0)
         {
@@ -742,7 +743,7 @@ U32 xFXStreakStart(F32 frequency, F32 alphaFadeRate, F32 alphaStart, U32 texture
                 textureID = xStrHash("fx_streak1");
             }
 
-            sStreakList[i].texturePtr = (RwTexture*) xSTFindAsset(textureID, NULL);
+            sStreakList[i].texturePtr = (RwTexture*)xSTFindAsset(textureID, NULL);
             if (sStreakList[i].texturePtr != NULL)
             {
                 sStreakList[i].textureRasterPtr = RwTextureGetRaster(sStreakList[i].texturePtr);
@@ -751,7 +752,6 @@ U32 xFXStreakStart(F32 frequency, F32 alphaFadeRate, F32 alphaStart, U32 texture
             {
                 return 0;
             }
-
         }
     }
 
diff --git a/src/SB/Core/x/xMath.cpp b/src/SB/Core/x/xMath.cpp
index a1bd2208b..adbc647a9 100644
--- a/src/SB/Core/x/xMath.cpp
+++ b/src/SB/Core/x/xMath.cpp
@@ -237,7 +237,7 @@ F32 xDangleClamp(F32 a)
 
 void xAccelMove(F32& x, F32& v, F32 a, F32 dt, F32 endx, F32 maxv)
 {
-	// Todo: These variable names aren't all right.
+    // Todo: These variable names aren't all right.
     F32 var_f31;
     F32 offset;
     F32 t1;
@@ -526,16 +526,80 @@ void xAccelStop(F32& x, F32& v, F32 a, F32 dt)
     }
 }
 
+F32 xFuncPiece_Eval(xFuncPiece* func, F32 param, xFuncPiece** iterator)
+{
+    while (func && func->end < param - 1e-5f)
+    {
+        func = func->next;
+    }
+
+    F32 result;
+    if (func)
+    {
+        result = func->coef[func->order];
+        for (S32 i = func->order - 1; i >= 0; i--)
+        {
+            result = result * param + func->coef[i];
+        }
+        if (iterator)
+        {
+            *iterator = func;
+        }
+    }
+    else
+    {
+        result = 0.0f;
+        if (iterator)
+        {
+            *iterator = NULL;
+        }
+    }
+
+    return result;
+}
+
 void xFuncPiece_EndPoints(xFuncPiece* func, F32 pi, F32 pf, F32 fi, F32 ff)
 {
-	F32 xfinv; // from DWARF data
-	F32 df; // not from DWARF data
+    F32 xfinv; // from DWARF data
+    F32 df; // not from DWARF data
 
     func->end = pf - pi;
     xfinv = (1.0f / func->end);
-	df = ff - fi;
+    df = ff - fi;
     func->order = 1;
     func->coef[0] = fi;
     func->coef[1] = df * xfinv;
     xFuncPiece_ShiftPiece(func, func, -pi);
 }
+
+void xFuncPiece_ShiftPiece(xFuncPiece* shift, xFuncPiece* func, F32 newZero)
+
+{
+    S32 i, j;
+    xFuncPiece temp;
+
+    for (i = 0; i < func->order; i++)
+    {
+        temp.coef[i] = 0.0f;
+    }
+
+    temp.coef[func->order] = func->coef[func->order];
+
+    for (i = func->order - 1; i >= 0; i--)
+    {
+        for (j = i; j < func->order; j++)
+        {
+            temp.coef[j] += newZero * temp.coef[j + 1];
+        }
+        temp.coef[i] += func->coef[i];
+    }
+
+    shift->order = func->order;
+
+    for (i = 0; i <= shift->order; i++)
+    {
+        shift->coef[i] = temp.coef[i];
+    }
+
+    shift->end = func->end - newZero;
+}
diff --git a/src/SB/Core/x/xMath3.cpp b/src/SB/Core/x/xMath3.cpp
index d931e4fa4..849cf1fb6 100644
--- a/src/SB/Core/x/xMath3.cpp
+++ b/src/SB/Core/x/xMath3.cpp
@@ -21,12 +21,55 @@ const xVec3 g_Onez = { 1, 1, 1 };
 const xQuat g_IQ = { 0.0f, 0.0f, 0.0f, 1.0f };
 xMat4x3 g_I3;
 
+void xMath3Init()
+{
+    iMath3Init();
+
+    g_I3.right.x = g_X3.x;
+    g_I3.right.y = g_X3.y;
+    g_I3.right.z = g_X3.z;
+    g_I3.up.x = g_Y3.x;
+    g_I3.up.y = g_Y3.y;
+    g_I3.up.z = g_Y3.z;
+    g_I3.at.x = g_Z3.x;
+    g_I3.at.y = g_Z3.y;
+    g_I3.at.z = g_Z3.z;
+    g_I3.pos.x = g_O3.x;
+    g_I3.pos.y = g_O3.y;
+    g_I3.pos.z = g_O3.z;
+}
+
+void xLine3VecDist2(const xVec3* p1, const xVec3* p2, const xVec3* v, xIsect* isx)
+{
+    xVec3 ldir;
+    xVec3Sub(&ldir, p2, p1);
+    xVec3Sub(&isx->norm, v, p1);
+
+    F32 ldirdotlv = xVec3Dot(&ldir, &isx->norm);
+    if (ldirdotlv <= 0.0f)
+    {
+        isx->dist = xVec3Length2(&isx->norm);
+        return;
+    }
+
+    F32 ldirlen2 = xVec3Length2(&ldir);
+    if (ldirdotlv >= ldirlen2)
+    {
+        xVec3Sub(&isx->norm, v, p2);
+        isx->dist = xVec3Length2(&isx->norm);
+        return;
+    }
+
+    F32 lvlen2 = xVec3Length2(&isx->norm);
+    isx->dist = lvlen2 - SQ(ldirdotlv) / ldirlen2;
+}
+
 S32 xPointInBox(const xBox* b, const xVec3* p)
 {
     S32 ret = 0;
-    if ((p->x >=b->lower.x) && (p->x <= b->upper.x))
+    if ((p->x >= b->lower.x) && (p->x <= b->upper.x))
     {
-        if ((p->y>= b->lower.y) && (p->y <= b->upper.y))
+        if ((p->y >= b->lower.y) && (p->y <= b->upper.y))
         {
             if ((p->z >= b->lower.z) && (p->z <= b->upper.z))
             {
@@ -37,6 +80,81 @@ S32 xPointInBox(const xBox* b, const xVec3* p)
     return (char)ret;
 }
 
+void xBoxInitBoundOBB(xBox* o, const xBox* b, const xMat4x3* m)
+{
+    xVec3 boxcent;
+    boxcent.x = 0.5f * (b->lower.x + b->upper.x);
+    boxcent.y = 0.5f * (b->lower.y + b->upper.y);
+    boxcent.z = 0.5f * (b->lower.z + b->upper.z);
+
+    F32 xmax = xabs(m->right.x * (b->upper.x - boxcent.x));
+    F32 ymax = xabs(m->right.y * (b->upper.x - boxcent.x));
+    F32 zmax = xabs(m->right.z * (b->upper.x - boxcent.x));
+
+    xmax += xabs(m->up.x * (b->upper.y - boxcent.y));
+    ymax += xabs(m->up.y * (b->upper.y - boxcent.y));
+    zmax += xabs(m->up.z * (b->upper.y - boxcent.y));
+
+    xmax += xabs(m->at.x * (b->upper.z - boxcent.z));
+    ymax += xabs(m->at.y * (b->upper.z - boxcent.z));
+    zmax += xabs(m->at.z * (b->upper.z - boxcent.z));
+
+    xMat4x3Toworld(&boxcent, m, &boxcent);
+
+    o->lower.x = boxcent.x - xmax;
+    o->lower.y = boxcent.y - ymax;
+    o->lower.z = boxcent.z - zmax;
+    o->upper.x = boxcent.x + xmax;
+    o->upper.y = boxcent.y + ymax;
+    o->upper.z = boxcent.z + zmax;
+}
+
+void xBoxInitBoundCapsule(xBox* b, const xCapsule* c)
+{
+    if (c->start.x < c->end.x)
+    {
+        b->lower.x = c->start.x - c->r;
+        b->upper.x = c->end.x + c->r;
+    }
+    else
+    {
+        b->lower.x = c->end.x - c->r;
+        b->upper.x = c->start.x + c->r;
+    }
+
+    if (c->start.y < c->end.y)
+    {
+        b->lower.y = c->start.y - c->r;
+        b->upper.y = c->end.y + c->r;
+    }
+    else
+    {
+        b->lower.y = c->end.y - c->r;
+        b->upper.y = c->start.y + c->r;
+    }
+
+    if (c->start.z < c->end.z)
+    {
+        b->lower.z = c->start.z - c->r;
+        b->upper.z = c->end.z + c->r;
+    }
+    else
+    {
+        b->lower.z = c->end.z - c->r;
+        b->upper.z = c->start.z + c->r;
+    }
+}
+
+void xBoxFromCone(xBox& box, const xVec3& center, const xVec3& dir, F32 dist, F32 r1, F32 r2)
+{
+    xBoxFromCircle(box, center, dir, r1);
+
+    xBox temp;
+    xBoxFromCircle(temp, center + dir * dist, dir, r2);
+
+    xBoxUnion(box, box, temp);
+}
+
 void xMat4x3Rot(xMat4x3* m, const xVec3* a, F32 t, const xVec3* p)
 {
     xMat4x3 temp;
@@ -46,7 +164,6 @@ void xMat4x3Rot(xMat4x3* m, const xVec3* a, F32 t, const xVec3* p)
     xMat3x3Identity(&temp);
     xVec3Inv(&temp.pos, p);
     xMat4x3Mul(m, &temp, m);
-
 }
 
 /* xMat4x3Mul (xMat4x3 *, xMat4x3 const *, xMat4x3 const *) */
@@ -110,15 +227,15 @@ void xMat3x3RotC(xMat3x3* m, F32 _x, F32 _y, F32 _z, F32 t)
     c = 1.0f - cos;
 
     m->right.x = (c * _x * _x) + cos;
-    m->right.y = (sin  * _z) + (c * _x * _y);
+    m->right.y = (sin * _z) + (c * _x * _y);
     m->right.z = (-sin * _y) + (c * _z * _x);
 
     m->up.x = (-sin * _z) + (c * _x * _y);
     m->up.y = (c * _y * _y) + cos;
     m->up.z = (sin * _x) + (c * _y * _z);
 
-    m->at.x = (sin  * _y)  + (c * _z * _x);
-    m->at.y = (-sin * _x)  + (c * _y * _z);
+    m->at.x = (sin * _y) + (c * _z * _x);
+    m->at.y = (-sin * _x) + (c * _y * _z);
     m->at.z = (c * _z * _z) + cos;
 
     m->flags = 0;
@@ -171,8 +288,8 @@ void xMat3x3Normalize(xMat3x3* o, const xMat3x3* m)
 void xMat3x3Tolocal(xVec3* o, const xMat3x3* m, const xVec3* v)
 {
     F32 sumRt = (m->right.x * m->right.x) + (m->right.y * m->right.y) + (m->right.z * m->right.z);
-    F32 sumUp = (m->up.x    * m->up.x)    + (m->up.y    * m->up.y)    + (m->up.z    * m->up.z);
-    F32 sumAt = (m->at.x    * m->at.x)    + (m->at.y    * m->at.y)    + (m->at.z    * m->at.z);
+    F32 sumUp = (m->up.x * m->up.x) + (m->up.y * m->up.y) + (m->up.z * m->up.z);
+    F32 sumAt = (m->at.x * m->at.x) + (m->at.y * m->at.y) + (m->at.z * m->at.z);
     xMat3x3LMulVec(o, m, v);
     o->x /= sumRt;
     o->y /= sumUp;
@@ -283,60 +400,54 @@ void xQuatDiff(xQuat* o, const xQuat* a, const xQuat* b)
     }
 }
 
-/* xQuatFromMat (xQuat *, xMat3x3 const *) */
+// Matching in Ratatouille, minus debug stuff: https://decomp.me/scratch/VthMZ
 void xQuatFromMat(xQuat* q, const xMat3x3* m)
 {
-    static S32 nxt[3] = { 1, 2, 0 };
+    F32* mp = (F32*)m;
+    F32* qvp = (F32*)q;
+    F32 tr = m->right.x + m->up.y + m->at.z;
+    F32 root;
 
-    F32 temp_f1;
-    F32 temp_f1_2;
-    F32 temp_f1_3;
-    F32 temp_f5;
-    F32 temp_f6;
-    S32 temp_r25;
-    F32 temp_r28;
-    F32 temp_r30;
-    F32 temp_r31;
-    F32 temp_r8;
-    S32 var_r29;
-
-    temp_f1 = m->at.z + (m->right.x + m->up.y);
-    if (temp_f1 > 0.0f)
+    if (tr > 0.0f)
     {
-        temp_f1_2 = xsqrt(1.0f + temp_f1);
-        q->s = 0.5f * temp_f1_2;
-        temp_f5 = 0.5f / temp_f1_2;
-        q->v.x = temp_f5 * (m->at.y - m->up.z);
-        q->v.y = temp_f5 * (m->right.z - m->at.x);
-        q->v.z = temp_f5 * (m->up.x - m->right.y);
-        return;
+        root = xsqrt(1.0f + tr);
+        q->s = 0.5f * root;
+        root = 0.5f / root;
+        q->v.x = root * (m->at.y - m->up.z);
+        q->v.y = root * (m->right.z - m->at.x);
+        q->v.z = root * (m->up.x - m->right.y);
     }
-    var_r29 = 0;
-    if (m->up.y > m->right.x)
+    else
     {
-        var_r29 = 1;
+        static S32 nxt[3] = { 1, 2, 0 };
+
+        S32 i = 0;
+        if (mp[5] > mp[0])
+            i = 1;
+        if (mp[10] > mp[i * 5])
+            i = 2;
+
+        S32 j = nxt[i];
+        S32 k = nxt[j];
+
+        root = xsqrt(mp[i * 5] - mp[j * 5] - mp[k * 5] + 1.0f);
+        if (xabs(root) < 1e-5f)
+        {
+            xQuatCopy(q, &g_IQ);
+            return;
+        }
+
+        qvp[i] = 0.5f * root;
+        root = 0.5f / root;
+        q->s = root * (mp[j + k * 4] - mp[k + j * 4]);
+        qvp[j] = root * (mp[i + j * 4] + mp[j + i * 4]);
+        qvp[k] = root * (mp[i + k * 4] + mp[k + i * 4]);
+
+        if (q->s < 0.0f)
+        {
+            xQuatFlip(q, q);
+        }
     }
-    // if (m->at.z > F32 (*(m + (var_r29 * 0x14)))) {
-    //     var_r29 = 2;
-    // }
-    // temp_r31 = var_r29 * 4;
-    // temp_r25 = nxt[var_r29];
-    // temp_r30 = temp_r25 * 4;
-    // temp_r28 = nxt[temp_r25];
-    // temp_f1_3 = xsqrt(1.0f + ((*(m + (var_r29 * 0x14)) - *(m + (temp_r25 * 0x14))) - *(m + (temp_r28 * 0x14))));
-    // if ((F32) fabs(temp_f1_3) < 0.00001f) {
-    //     xQuatCopy(q, &g_IQ);
-    //     return;
-    // }
-    // temp_r8 = temp_r28 * 4;
-    // *(q + temp_r31) = 0.5f * temp_f1_3;
-    // temp_f6 = 0.5f / temp_f1_3;
-    // q->unkC = temp_f6 * (*(m + ((temp_r25 + temp_r8) * 4)) - *(m + ((temp_r28 + temp_r30) * 4)));
-    // *(q + temp_r30) = temp_f6 * (*(m + ((var_r29 + temp_r30) * 4)) + *(m + ((temp_r25 + temp_r31) * 4)));
-    // *(q + temp_r8) = temp_f6 * (*(m + ((var_r29 + temp_r8) * 4)) + *(m + ((temp_r28 + temp_r31) * 4)));
-    // if (q->unkC < 0.0f) {
-    //     xQuatFlip(q, q);
-    // }
 }
 
 void xQuatFromAxisAngle(xQuat* q, const xVec3* a, F32 t)
@@ -361,6 +472,34 @@ void xQuatToAxisAngle(const xQuat* q, xVec3* a, F32* t)
     xVec3Normalize(a, &q->v);
 }
 
+F32 xQuatNormalize(xQuat* o, const xQuat* q)
+{
+    F32 one_len, len, len2;
+    len2 = xQuatLength2(q);
+    if (len2 == 1.0f)
+    {
+        if (o != q)
+        {
+            xQuatCopy(o, q);
+        }
+        return 1.0f;
+    }
+
+    if (len2 == 0.0f)
+    {
+        if (o != q)
+        {
+            xQuatCopy(o, &g_IQ);
+        }
+        return 0.0f;
+    }
+
+    len = xsqrt(len2);
+    one_len = 1.0f / len;
+    xQuatSMul(o, q, one_len);
+    return len;
+}
+
 /* xQuatSlerp (xQuat *, xQuat const *, xQuat const *, float) */
 void xQuatSlerp(xQuat* q, const xQuat* a, const xQuat* b, F32 t)
 {
@@ -470,7 +609,7 @@ F32 xMat3x3LookVec(xMat3x3* m, const xVec3* at)
     temp_f31 = xVec3Normalize(&m->at, at);
     temp_r3 = &m->at;
     xVec3Inv(temp_r3, temp_r3);
-    if ((F32)__fabs(1.0f -  m->at.y) < 0.00001f)
+    if ((F32)__fabs(1.0f - m->at.y) < 0.00001f)
     {
         m->right.x = 1.0f;
         m->right.y = 0.0f;
@@ -483,7 +622,7 @@ F32 xMat3x3LookVec(xMat3x3* m, const xVec3* at)
         m->at.z = 0.0f;
         return temp_f31;
     }
-    if ((F32)__fabs(1.0f +  m->at.y) < 0.00001f)
+    if ((F32)__fabs(1.0f + m->at.y) < 0.00001f)
     {
         m->right.x = -1.0f;
         m->right.y = 0.0f;
@@ -688,10 +827,10 @@ void xBoxUnion(xBox& a, const xBox& b, const xBox& c)
 
 void xMat3x3LMulVec(xVec3* o, const xMat3x3* m, const xVec3* v)
 {
-	F32 y = (m->up.x * v->x) + (m->up.y * v->y) + (m->up.z * v->z);
-	F32 z = (m->at.x * v->x) + (m->at.y * v->y) + (m->at.z * v->z);
+    F32 y = (m->up.x * v->x) + (m->up.y * v->y) + (m->up.z * v->z);
+    F32 z = (m->at.x * v->x) + (m->at.y * v->y) + (m->at.z * v->z);
 
-	o->x = (m->right.x * v->x) + (m->right.y * v->y) + (m->right.z * v->z);
+    o->x = (m->right.x * v->x) + (m->right.y * v->y) + (m->right.z * v->z);
     o->y = y;
-	o->z = z;
+    o->z = z;
 }
diff --git a/src/SB/Core/x/xMath3.h b/src/SB/Core/x/xMath3.h
index 3ece8eae3..02068cb80 100644
--- a/src/SB/Core/x/xMath3.h
+++ b/src/SB/Core/x/xMath3.h
@@ -5,6 +5,7 @@
 
 #include "xVec3.h"
 #include "xVec3Inlines.h"
+#include "xIsect.h"
 
 // Size: 0x30
 struct xMat3x3
@@ -73,6 +74,13 @@ struct xCylinder
     F32 h;
 };
 
+struct xCapsule
+{
+    xVec3 start;
+    xVec3 end;
+    F32 r;
+};
+
 struct xQuat
 {
     xVec3 v;
@@ -122,6 +130,11 @@ extern const xVec3 g_NZ3;
 extern const xVec3 g_Onez;
 extern xMat4x3 g_I3;
 
+void xMath3Init();
+void xLine3VecDist2(const xVec3* p1, const xVec3* p2, const xVec3* v, xIsect* isx);
+void xBoxInitBoundOBB(xBox* o, const xBox* b, const xMat4x3* m);
+void xBoxInitBoundCapsule(xBox* b, const xCapsule* c);
+void xBoxFromCone(xBox& box, const xVec3& center, const xVec3& dir, F32 dist, F32 r1, F32 r2);
 void xMat3x3Copy(xMat3x3* o, const xMat3x3* m); // TODO: These functions should be inline
 void xMat4x3Copy(xMat4x3* o, const xMat4x3* m);
 void xMat4x3Mul(xMat4x3* o, const xMat4x3* a, const xMat4x3* b);
@@ -163,12 +176,14 @@ void xMat3x3SMul(xMat3x3*, const xMat3x3*, F32);
 void xBoxFromLine(xBox& box, const xLine3& line);
 void xBoxFromRay(xBox& box, const xRay3& ray);
 void xMat3x3Identity(xMat3x3* matrix); // TODO: These functions should be inline
+void xBoxFromCircle(xBox& box, const xVec3& center, const xVec3& dir, F32 r);
 S32 xPointInBox(const xBox* b, const xVec3* p);
 void xMat3x3LMulVec(xVec3* o, const xMat3x3* m, const xVec3* v);
 
 void xQuatMul(xQuat* o, const xQuat* a, const xQuat* b);
 void xQuatFlip(xQuat* o1, xQuat* o2);
 void xQuatNormalize(xQuat* arg01, xQuat* arg02);
+F32 xQuatLength2(const xQuat* q);
 
 void xQuatSMul(xQuat* q, const xQuat* a, F32 t);
 void xQuatAdd(xQuat* q, const xQuat* a, const xQuat* b);
diff --git a/src/SB/Core/x/xQuickCull.cpp b/src/SB/Core/x/xQuickCull.cpp
index 8feb55c5b..7c5580a4b 100644
--- a/src/SB/Core/x/xQuickCull.cpp
+++ b/src/SB/Core/x/xQuickCull.cpp
@@ -1,7 +1,11 @@
 #include "xQuickCull.h"
+#include "xRay3.h"
+#include "xBound.h"
 
 #include <types.h>
 
+xQCControl xqc_def_ctrl;
+
 void xQuickCullInit(xQCControl* ctrl, F32 xmin, F32 ymin, F32 zmin, F32 xmax, F32 ymax, F32 zmax)
 {
     ctrl->world_xmin = xmin;
@@ -39,3 +43,150 @@ S32 xQuickCullIsects(const xQCData* a, const xQCData* b)
     return a->xmin <= b->xmax && a->ymin <= b->ymax && a->zmin <= b->zmax && b->xmin <= a->xmax &&
            b->ymin <= a->ymax && b->zmin <= a->zmax;
 }
+
+void xQuickCullForBound(xQCControl* ctrl, xQCData* q, const xBound* b)
+{
+    if (b->type == 1)
+    {
+        xQuickCullForSphere(ctrl, q, &b->sph);
+    }
+    else if (b->type == 2)
+    {
+        xQuickCullForBox(ctrl, q, &b->box.box);
+    }
+    else if (b->type == 4)
+    {
+        xQuickCullForOBB(ctrl, q, &b->box.box, b->mat);
+    }
+}
+
+static void xQuickCullCellForVec(xQCControl* ctrl, xQCData* c, const xVec3* v)
+{
+    c->xmin = CLAMP((int)((v->x - ctrl->center_x) * ctrl->scale_x), -127, 127);
+    c->ymin = CLAMP((int)((v->y - ctrl->center_y) * ctrl->scale_y), -127, 127);
+    c->zmin = CLAMP((int)((v->z - ctrl->center_z) * ctrl->scale_z), -127, 127);
+    c->zmin_dup = c->zmin;
+    c->xmax = c->xmin;
+    c->ymax = c->ymin;
+    c->zmax = c->zmin;
+    c->zmax_dup = c->zmin_dup;
+}
+
+static void xQuickCullCellMerge(xQCData* o, const xQCData* a, const xQCData* b)
+{
+    o->xmin = MIN(a->xmin, b->xmin);
+    o->ymin = MIN(a->ymin, b->ymin);
+    o->zmin = MIN(a->zmin, b->zmin);
+    o->zmin_dup = o->zmin;
+    o->xmax = MAX(a->xmax, b->xmax);
+    o->ymax = MAX(a->ymax, b->ymax);
+    o->zmax = MAX(a->zmax, b->zmax);
+    o->zmax_dup = o->zmax;
+}
+
+void xQuickCullForLine(xQCControl* ctrl, xQCData* q, const xLine3* ln)
+{
+    xQCData a;
+    xQuickCullCellForVec(ctrl, &a, &ln->p1);
+
+    xQCData b;
+    xQuickCullCellForVec(ctrl, &b, &ln->p2);
+
+    xQuickCullCellMerge(q, &a, &b);
+}
+
+void xQuickCullForRay(xQCControl* ctrl, xQCData* q, const xRay3* r)
+{
+    xLine3 ln;
+
+    if (r->flags & 0x400)
+    {
+        xVec3 delta;
+        delta.x = r->dir.x * r->min_t, delta.y = r->dir.y * r->min_t, delta.z = r->dir.z * r->min_t;
+        ln.p1.x = r->origin.x + delta.x, ln.p1.y = r->origin.y + delta.y,
+        ln.p1.z = r->origin.z + delta.z;
+    }
+    else
+    {
+        ln.p1.x = r->origin.x, ln.p1.y = r->origin.y, ln.p1.z = r->origin.z;
+    }
+
+    if (r->flags & 0x800)
+    {
+        F32 len;
+        if (r->flags & 0x400)
+        {
+            len = r->max_t - r->min_t;
+        }
+        else
+        {
+            len = r->max_t;
+        }
+        ln.p2.x = r->dir.x * len, ln.p2.y = r->dir.y * len, ln.p2.z = r->dir.z * len;
+    }
+    else
+    {
+        ln.p2.x = r->dir.x, ln.p2.y = r->dir.y, ln.p2.z = r->dir.z;
+    }
+
+    ln.p2.x = ln.p1.x + ln.p2.x, ln.p2.y = ln.p1.y + ln.p2.y, ln.p2.z = ln.p1.z + ln.p2.z;
+
+    xQCData a;
+    xQuickCullCellForVec(ctrl, &a, &ln.p1);
+
+    xQCData b;
+    xQuickCullCellForVec(ctrl, &b, &ln.p2);
+
+    xQuickCullCellMerge(q, &a, &b);
+}
+
+void xQuickCullForSphere(xQCControl* ctrl, xQCData* q, const xSphere* s)
+{
+    xVec3 v1;
+    xVec3 v2;
+    F32 radius_adjusted = 0.05f + s->r;
+
+    v1.x = -radius_adjusted, v1.y = -radius_adjusted, v1.z = -radius_adjusted;
+    v2.x = radius_adjusted, v2.y = radius_adjusted, v2.z = radius_adjusted;
+
+    v1.x += s->center.x, v1.y += s->center.y, v1.z += s->center.z;
+    v2.x += s->center.x, v2.y += s->center.y, v2.z += s->center.z;
+
+    xQCData a;
+    xQuickCullCellForVec(ctrl, &a, &v1);
+
+    xQCData b;
+    xQuickCullCellForVec(ctrl, &b, &v2);
+
+    xQuickCullCellMerge(q, &a, &b);
+}
+
+void xQuickCullForBox(xQCControl* ctrl, xQCData* q, const xBox* box)
+{
+    xQCData a;
+    xQuickCullCellForVec(ctrl, &a, &box->lower);
+
+    xQCData b;
+    xQuickCullCellForVec(ctrl, &b, &box->upper);
+
+    xQuickCullCellMerge(q, &a, &b);
+}
+
+void xQuickCullForOBB(xQCControl* ctrl, xQCData* q, const xBox* b, const xMat4x3* m)
+{
+    xBox worldbox;
+    xBoxInitBoundOBB(&worldbox, b, m);
+    xQuickCullForBox(ctrl, q, &worldbox);
+}
+
+void xQuickCullForEverything(xQCData* q)
+{
+    q->xmin = -128;
+    q->ymin = -128;
+    q->zmin = -128;
+    q->zmin_dup = -128;
+    q->xmax = 127;
+    q->ymax = 127;
+    q->zmax = 127;
+    q->zmax_dup = 127;
+}
diff --git a/src/SB/Core/x/xQuickCull.h b/src/SB/Core/x/xQuickCull.h
index cff957b53..ab2726598 100644
--- a/src/SB/Core/x/xQuickCull.h
+++ b/src/SB/Core/x/xQuickCull.h
@@ -46,13 +46,12 @@ struct xBox;
 void xQuickCullInit(const xBox* box);
 void xQuickCullInit(xQCControl* ctrl, const xBox* box);
 
-void xQuickCullInit(xQCControl* ctrl, F32 xmin, F32 ymin, F32 zmin, F32 xmax,
-                    F32 ymax, F32 zmax);
+void xQuickCullInit(xQCControl* ctrl, F32 xmin, F32 ymin, F32 zmin, F32 xmax, F32 ymax, F32 zmax);
 void xQuickCullInit(xQCControl* ctrl, const xBox* box);
 S32 xQuickCullIsects(const xQCData* a, const xQCData* b);
 void xQuickCullForBound(xQCControl* ctrl, xQCData* q, const xBound* b);
-void xQuickCullCellForVec(xQCControl* ctrl, xQCData* c, const xVec3* v);
-void xQuickCullCellMerge(xQCData* dest, const xQCData* a, const xQCData* b);
+static void xQuickCullCellForVec(xQCControl* ctrl, xQCData* c, const xVec3* v);
+static void xQuickCullCellMerge(xQCData* dest, const xQCData* a, const xQCData* b);
 void xQuickCullForLine(xQCControl* ctrl, xQCData* q, const xLine3* ln);
 void xQuickCullForRay(xQCControl* ctrl, xQCData* q, const xRay3* r);
 void xQuickCullForSphere(xQCControl* ctrl, xQCData* q, const xSphere* s);
diff --git a/src/SB/Core/x/xordarray.cpp b/src/SB/Core/x/xordarray.cpp
index d3c405837..d0d473f13 100644
--- a/src/SB/Core/x/xordarray.cpp
+++ b/src/SB/Core/x/xordarray.cpp
@@ -5,7 +5,7 @@
 
 void XOrdInit(st_XORDEREDARRAY* array, S32 size, S32 tempAlloc)
 {
-    U32 cnt = 1;
+    S32 cnt = 1;
     if (size >= 1)
     {
         cnt = size;
@@ -20,11 +20,11 @@ void XOrdInit(st_XORDEREDARRAY* array, S32 size, S32 tempAlloc)
     }
     array->cnt = 0;
     array->max = cnt;
-    array->warnlvl = 0.95f * (cnt ^ 0x80000000);
+    array->warnlvl = 0.95f * (cnt ^ (S32)0.0);
     if (array->warnlvl == array->max)
     {
         cnt = array->max - 1;
-        array->warnlvl = cnt & ~((S32)cnt >> 0x1f);
+        array->warnlvl = cnt & ~(cnt >> 0x1f);
     }
 }
 
@@ -56,27 +56,23 @@ void XOrdAppend(st_XORDEREDARRAY* array, void* elt)
 
 void XOrdInsert(st_XORDEREDARRAY* array, void* elt, XOrdCompareCallback compare)
 {
-    if (array->cnt < array->max)
+    S32 i = 0;
+
+    if (array->cnt >= array->max)
+        return;
+    array->cnt++;
+
+    for (i = array->cnt - 1; i > 0; i--)
     {
-        array->cnt++;
-        S32 pos = array->cnt - 1;
-        void* currElement = (void*)(pos * sizeof(void*));
-        while (pos > 0)
+        if (compare(array->list[i - 1], elt) <= 0)
         {
-            // FIXME: currElement
-            // S32 score = compare(array->list + currElement - sizeof(void*), elt);
-            // if (score <= 0)
-            // {
-            //     array->list[pos] = elt;
-            //     return;
-            // }
-            // pos--;
-            // void* tmp = (void*)(array->list + currElement);
-            // currElement--;
-            // *tmp = tmp[-1];
+            array->list[i] = elt;
+            return;
         }
-        *array->list = elt;
+        array->list[i] = array->list[i - 1];
     }
+
+    array->list[0] = elt;
 }
 
 void* XOrdRemove(st_XORDEREDARRAY* array, void* elt, S32 index)
@@ -128,53 +124,54 @@ void* XOrdRemove(st_XORDEREDARRAY* array, void* elt, S32 index)
 
 S32 XOrdLookup(st_XORDEREDARRAY* array, const void* key, XOrdTestCallback test)
 {
-    S32 v, index, rightBound, leftBound;
-    leftBound = 0;
-    index = array->cnt;
-    do
+    S32 da_idx = -1;
+    S32 k0 = 0;
+    S32 k1 = 0;
+    S32 k = 0;
+    S32 v = 0;
+
+    k0 = 0;
+    k1 = array->cnt;
+    while (k1 > k0)
     {
-        rightBound = index;
-        if (rightBound <= leftBound)
-        {
-            return -1;
-        }
-        index = (leftBound + rightBound) / 2;
-        v = test(key, array->list[index]);
+        k = (k0 + k1) / 2;
+        v = test(key, array->list[k]);
         if (v == 0)
-            break;
-        if (0 < v)
         {
-            leftBound = index + 1;
-            index = rightBound;
+            da_idx = k;
+            break;
         }
-    } while (true);
-    return index;
+        if (v > 0)
+            k0 = k + 1;
+        else
+            k1 = k;
+    }
+
+    return da_idx;
 }
 
-void XOrdSort(st_XORDEREDARRAY* array, S32 (*test)(void*, void*))
+void XOrdSort(st_XORDEREDARRAY* array, XOrdCompareCallback test)
 {
     void** list = array->list;
-    S32 num = 1;
-    // FIXME: cnt??
-    // while (num <= cnt)
-    // {
-    //     num = num * 3 + 1;
-    // }
-    for (;;)
+    S32 num = array->cnt;
+    S32 i = 0;
+    S32 j = 0;
+    S32 h = 1;
+    void* v = NULL;
+
+    while (h <= num)
+        h = h * 3 + 1;
+    while (h != 1)
     {
-        if (num == 1)
+        h /= 3;
+        for (i = h; i < num; i++)
         {
-            return;
+            v = list[i];
+            for (j = i; j >= h && test(v, list[j - h]) < 0; j -= h)
+            {
+                list[j] = list[j - h];
+            }
+            list[j] = v;
         }
-        num = num / 3 + (num >> 0x1f);
-        num = num - (num >> 0x1f);
-        S32 numPos = num * sizeof(void*);
-        void** currItem = list + num;
-        S32 i = num;
-        // FIXME: cnt??
-        // while (i < cnt)
-        // {
-        //     // TODO!!!
-        // }
     }
 }
diff --git a/src/SB/Game/zFMV.h b/src/SB/Game/zFMV.h
index 1af81e1e4..53d593d4a 100644
--- a/src/SB/Game/zFMV.h
+++ b/src/SB/Game/zFMV.h
@@ -25,7 +25,7 @@ struct zFMVFile
     char fileName[32];
 };
 
-U32 zFMVPlay(char* filename, U32 buttons, F32 time, bool skippable, bool lockController);
+U32 zFMVPlay(char* filename, unsigned int buttons, F32 time, bool skippable, bool lockController);
 char* zFMVFileGetName(eFMVFile fileEnum);
 
 #endif
diff --git a/src/bink/include/bink.h b/src/bink/include/bink.h
new file mode 100644
index 000000000..cf1a381c6
--- /dev/null
+++ b/src/bink/include/bink.h
@@ -0,0 +1,734 @@
+#ifndef __BINKH__
+#define __BINKH__
+
+#define BINKMAJORVERSION 1
+#define BINKMINORVERSION 5
+#define BINKSUBVERSION 21
+#define BINKVERSION "1.5y"
+#define BINKDATE "2003-09-23"
+
+#ifndef __RADRES__
+
+#ifndef __RADBASEH__
+#include "radbase.h"
+#endif
+
+RADDEFSTART
+
+typedef struct BINK PTR4* HBINK;
+
+struct BINKIO;
+typedef s32(RADLINK PTR4* BINKIOOPEN)(struct BINKIO PTR4* Bnkio, const char PTR4* name, u32 flags);
+typedef u32(RADLINK PTR4* BINKIOREADHEADER)(struct BINKIO PTR4* Bnkio, s32 Offset, void PTR4* Dest,
+                                            u32 Size);
+typedef u32(RADLINK PTR4* BINKIOREADFRAME)(struct BINKIO PTR4* Bnkio, u32 Framenum, s32 origofs,
+                                           void PTR4* dest, u32 size);
+typedef u32(RADLINK PTR4* BINKIOGETBUFFERSIZE)(struct BINKIO PTR4* Bnkio, u32 Size);
+typedef void(RADLINK PTR4* BINKIOSETINFO)(struct BINKIO PTR4* Bnkio, void PTR4* Buf, u32 Size,
+                                          u32 FileSize, u32 simulate);
+typedef u32(RADLINK PTR4* BINKIOIDLE)(struct BINKIO PTR4* Bnkio);
+typedef void(RADLINK PTR4* BINKIOCLOSE)(struct BINKIO PTR4* Bnkio);
+
+typedef void(RADLINK PTR4* BINKCBSUSPEND)(struct BINKIO PTR4* Bnkio);
+typedef s32(RADLINK PTR4* BINKCBTRYSUSPEND)(struct BINKIO PTR4* Bnkio);
+typedef void(RADLINK PTR4* BINKCBRESUME)(struct BINKIO PTR4* Bnkio);
+typedef void(RADLINK PTR4* BINKCBIDLE)(struct BINKIO PTR4* Bnkio);
+
+// Unsorted
+// Pulled from previous bink.h to maintain the build
+extern void RADSetAudioMemory(void* (*malloc)(size_t), void (*free)(void*));
+extern void RADSetMemory(void* (*malloc)(size_t), void (*free)(void*));
+//
+
+typedef struct BINKIO
+{
+    BINKIOREADHEADER ReadHeader;
+    BINKIOREADFRAME ReadFrame;
+    BINKIOGETBUFFERSIZE GetBufferSize;
+    BINKIOSETINFO SetInfo;
+    BINKIOIDLE Idle;
+    BINKIOCLOSE Close;
+    HBINK bink;
+    volatile u32 ReadError;
+    volatile u32 DoingARead;
+    volatile u32 BytesRead;
+    volatile u32 Working;
+    volatile u32 TotalTime;
+    volatile u32 ForegroundTime;
+    volatile u32 IdleTime;
+    volatile u32 ThreadTime;
+    volatile u32 BufSize;
+    volatile u32 BufHighUsed;
+    volatile u32 CurBufSize;
+    volatile u32 CurBufUsed;
+    volatile u8 iodata[128 + 32];
+
+    // filled in by the caller
+    BINKCBSUSPEND suspend_callback;
+    BINKCBTRYSUSPEND try_suspend_callback;
+    BINKCBRESUME resume_callback;
+    BINKCBIDLE idle_on_callback;
+    volatile u32 callback_control[16]; // buffer for background IO callback
+} BINKIO;
+
+struct BINKSND;
+typedef s32(RADLINK PTR4* BINKSNDOPEN)(struct BINKSND PTR4* BnkSnd, u32 freq, s32 bits, s32 chans,
+                                       u32 flags, HBINK bink);
+typedef s32(RADLINK PTR4* BINKSNDREADY)(struct BINKSND PTR4* BnkSnd);
+typedef s32(RADLINK PTR4* BINKSNDLOCK)(struct BINKSND PTR4* BnkSnd, u8 PTR4* PTR4* addr,
+                                       u32 PTR4* len);
+typedef s32(RADLINK PTR4* BINKSNDUNLOCK)(struct BINKSND PTR4* BnkSnd, u32 filled);
+typedef void(RADLINK PTR4* BINKSNDVOLUME)(struct BINKSND PTR4* BnkSnd, s32 volume);
+typedef void(RADLINK PTR4* BINKSNDPAN)(struct BINKSND PTR4* BnkSnd, s32 pan);
+typedef void(RADLINK PTR4* BINKSNDMIXBINS)(struct BINKSND PTR4* BnkSnd, u32 PTR4* mix_bins,
+                                           u32 total);
+typedef void(RADLINK PTR4* BINKSNDMIXBINVOLS)(struct BINKSND PTR4* BnkSnd, u32 PTR4* vol_mix_bins,
+                                              s32 PTR4* volumes, u32 total);
+typedef s32(RADLINK PTR4* BINKSNDONOFF)(struct BINKSND PTR4* BnkSnd, s32 status);
+typedef s32(RADLINK PTR4* BINKSNDPAUSE)(struct BINKSND PTR4* BnkSnd, s32 status);
+typedef void(RADLINK PTR4* BINKSNDCLOSE)(struct BINKSND PTR4* BnkSnd);
+
+typedef BINKSNDOPEN(RADLINK PTR4* BINKSNDSYSOPEN)(u32 param);
+
+typedef struct BINKSND
+{
+    BINKSNDREADY Ready;
+    BINKSNDLOCK Lock;
+    BINKSNDUNLOCK Unlock;
+    BINKSNDVOLUME Volume;
+    BINKSNDPAN Pan;
+    BINKSNDPAUSE Pause;
+    BINKSNDONOFF SetOnOff;
+    BINKSNDCLOSE Close;
+    BINKSNDMIXBINS MixBins;
+    BINKSNDMIXBINVOLS MixBinVols;
+
+    u32 sndbufsize; // sound buffer size
+    u8 PTR4* sndbuf; // sound buffer
+    u8 PTR4* sndend; // end of the sound buffer
+    u8 PTR4* sndwritepos; // current write position
+    u8 PTR4* sndreadpos; // current read position
+    u32 sndcomp; // sound compression handle
+    u32 sndamt; // amount of sound currently in the buffer
+    u32 sndconvert8; // convert back to 8-bit sound at runtime
+    u32 sndendframe; // frame number that the sound ends on
+    u32 sndprime; // amount of data to prime the playahead
+    u32 sndpad; // padded this much audio
+
+    u32 BestSizeIn16;
+    u32 BestSizeMask;
+    u32 SoundDroppedOut;
+    s32 NoThreadService;
+    s32 OnOff;
+    u32 Latency;
+    u32 VideoScale;
+    u32 freq;
+    s32 bits, chans;
+    u8 snddata[256];
+} BINKSND;
+
+typedef struct BINKRECT
+{
+    s32 Left, Top, Width, Height;
+} BINKRECT;
+
+#define BINKMAXDIRTYRECTS 8
+
+typedef struct BUNDLEPOINTERS
+{
+    void* typeptr;
+    void* type16ptr;
+    void* colorptr;
+    void* bits2ptr;
+    void* motionXptr;
+    void* motionYptr;
+    void* dctptr;
+    void* mdctptr;
+    void* patptr;
+} BUNDLEPOINTERS;
+
+typedef struct BINK
+{
+    u32 Width; // Width (1 based, 640 for example)
+    u32 Height; // Height (1 based, 480 for example)
+    u32 Frames; // Number of frames (1 based, 100 = 100 frames)
+    u32 FrameNum; // Frame to *be* displayed (1 based)
+    u32 LastFrameNum; // Last frame decompressed or skipped (1 based)
+
+    u32 FrameRate; // Frame Rate Numerator
+    u32 FrameRateDiv; // Frame Rate Divisor (frame rate=numerator/divisor)
+
+    u32 ReadError; // Non-zero if a read error has ocurred
+    u32 OpenFlags; // flags used on open
+    u32 BinkType; // Bink flags
+
+    u32 Size; // size of file
+    u32 FrameSize; // The current frame's size in bytes
+    u32 SndSize; // The current frame sound tracks' size in bytes
+
+    BINKRECT FrameRects[BINKMAXDIRTYRECTS]; // Dirty rects from BinkGetRects
+    s32 NumRects;
+
+    u32 PlaneNum; // which set of planes is current
+    void PTR4* YPlane[2]; // pointer to the uncompressed Y (Cr and Cr follow)
+    void PTR4* APlane[2]; // decompressed alpha plane (if present)
+    u32 YWidth; // widths and heights of the video planes
+    u32 YHeight;
+    u32 UVWidth;
+    u32 UVHeight;
+
+    void PTR4* MaskPlane; // pointer to the mask plane (Ywidth/16*Yheight/16)
+    u32 MaskPitch; // Mask Pitch
+    u32 MaskLength; // total length of the mask plane
+
+    u32 LargestFrameSize; // Largest frame size
+    u32 InternalFrames; // how many frames were potentially compressed
+
+    s32 NumTracks; // how many tracks
+
+    u32 Highest1SecRate; // Highest 1 sec data rate
+    u32 Highest1SecFrame; // Highest 1 sec data rate starting frame
+
+    s32 Paused; // is the bink movie paused?
+
+    u32 BackgroundThread; // handle to background thread
+
+    // everything below is for internal Bink use
+
+    void PTR4* compframe; // compressed frame data
+    void PTR4* preloadptr; // preloaded compressed frame data
+    u32* frameoffsets; // offsets of each of the frames
+
+    BINKIO bio; // IO structure
+    u8 PTR4* ioptr; // io buffer ptr
+    u32 iosize; // io buffer size
+    u32 decompwidth; // width not include scaling
+    u32 decompheight; // height not include scaling
+
+    s32 PTR4* trackindexes; // track indexes
+    u32 PTR4* tracksizes; // largest single frame of track
+    u32 PTR4* tracktypes; // type of each sound track
+    s32 PTR4* trackIDs; // external track numbers
+
+    u32 numrects; // number of rects from BinkGetRects
+
+    u32 playedframes; // how many frames have we played
+    u32 firstframetime; // very first frame start
+    u32 startframetime; // start frame start
+    u32 startblittime; // start of blit period
+    u32 startsynctime; // start of synched time
+    u32 startsyncframe; // frame of startsynctime
+    u32 twoframestime; // two frames worth of time
+    u32 entireframetime; // entire frame time
+
+    u32 slowestframetime; // slowest frame in ms
+    u32 slowestframe; // slowest frame number
+    u32 slowest2frametime; // second slowest frame in ms
+    u32 slowest2frame; // second slowest frame
+
+    u32 soundon; // sound turned on?
+    u32 videoon; // video turned on?
+
+    u32 totalmem; // total memory used
+    u32 timevdecomp; // total time decompressing video
+    u32 timeadecomp; // total time decompressing audio
+    u32 timeblit; // total time blitting
+    u32 timeopen; // total open time
+
+    u32 fileframerate; // frame rate originally in the file
+    u32 fileframeratediv;
+
+    u32 runtimeframes; // max frames for runtime analysis
+    u32 runtimemoveamt; // bytes to move each frame
+    u32 PTR4* rtframetimes; // start times for runtime frames
+    u32 PTR4* rtadecomptimes; // decompress times for runtime frames
+    u32 PTR4* rtvdecomptimes; // decompress times for runtime frames
+    u32 PTR4* rtblittimes; // blit times for runtime frames
+    u32 PTR4* rtreadtimes; // read times for runtime frames
+    u32 PTR4* rtidlereadtimes; // idle read times for runtime frames
+    u32 PTR4* rtthreadreadtimes; // thread read times for runtime frames
+
+    u32 lastblitflags; // flags used on last blit
+    u32 lastdecompframe; // last frame number decompressed
+
+    u32 lastresynctime; // last loop point that we did a resync on
+    u32 doresync; // should we do a resync in the next doframe?
+
+    u32 playingtracks; // how many tracks are playing
+    u32 soundskips; // number of sound stops
+    BINKSND PTR4* bsnd; // SND structures
+    u32 skippedlastblit; // skipped last frame?
+    u32 skipped_this_frame; // skipped the current frame?
+    u32 skippedblits; // how many blits were skipped
+
+    BUNDLEPOINTERS bunp; // pointers to internal temporary memory
+    u32 skipped_in_a_row; // how many frames have we skipped in a row
+    u32 big_sound_skip_adj; // adjustment for large skips
+    u32 big_sound_skip_reduce; // amount to reduce large skips by each frame
+    u32 last_time_almost_empty; // time of last almost empty IO buffer
+    u32 last_read_count; // counter to keep track of the last bink IO
+    u32 last_sound_count; // counter to keep track of the last bink sound
+    u32 snd_callback_buffer[16]; // buffer for background sound callback
+} BINK;
+
+typedef struct BINKSUMMARY
+{
+    u32 Width; // Width of frames
+    u32 Height; // Height of frames
+    u32 TotalTime; // total time (ms)
+    u32 FileFrameRate; // frame rate
+    u32 FileFrameRateDiv; // frame rate divisor
+    u32 FrameRate; // frame rate
+    u32 FrameRateDiv; // frame rate divisor
+    u32 TotalOpenTime; // Time to open and prepare for decompression
+    u32 TotalFrames; // Total Frames
+    u32 TotalPlayedFrames; // Total Frames played
+    u32 SkippedFrames; // Total number of skipped frames
+    u32 SkippedBlits; // Total number of skipped blits
+    u32 SoundSkips; // Total number of sound skips
+    u32 TotalBlitTime; // Total time spent blitting
+    u32 TotalReadTime; // Total time spent reading
+    u32 TotalVideoDecompTime; // Total time spent decompressing video
+    u32 TotalAudioDecompTime; // Total time spent decompressing audio
+    u32 TotalIdleReadTime; // Total time spent reading while idle
+    u32 TotalBackReadTime; // Total time spent reading in background
+    u32 TotalReadSpeed; // Total io speed (bytes/second)
+    u32 SlowestFrameTime; // Slowest single frame time (ms)
+    u32 Slowest2FrameTime; // Second slowest single frame time (ms)
+    u32 SlowestFrameNum; // Slowest single frame number
+    u32 Slowest2FrameNum; // Second slowest single frame number
+    u32 AverageDataRate; // Average data rate of the movie
+    u32 AverageFrameSize; // Average size of the frame
+    u32 HighestMemAmount; // Highest amount of memory allocated
+    u32 TotalIOMemory; // Total extra memory allocated
+    u32 HighestIOUsed; // Highest extra memory actually used
+    u32 Highest1SecRate; // Highest 1 second rate
+    u32 Highest1SecFrame; // Highest 1 second start frame
+} BINKSUMMARY;
+
+typedef struct BINKREALTIME
+{
+    u32 FrameNum; // Current frame number
+    u32 FrameRate; // frame rate
+    u32 FrameRateDiv; // frame rate divisor
+    u32 Frames; // frames in this sample period
+    u32 FramesTime; // time is ms for these frames
+    u32 FramesVideoDecompTime; // time decompressing these frames
+    u32 FramesAudioDecompTime; // time decompressing these frames
+    u32 FramesReadTime; // time reading these frames
+    u32 FramesIdleReadTime; // time reading these frames at idle
+    u32 FramesThreadReadTime; // time reading these frames in background
+    u32 FramesBlitTime; // time blitting these frames
+    u32 ReadBufferSize; // size of read buffer
+    u32 ReadBufferUsed; // amount of read buffer currently used
+    u32 FramesDataRate; // data rate for these frames
+} BINKREALTIME;
+
+#define BINKMARKER1 'fKIB'
+#define BINKMARKER2 'gKIB' // new Bink files use this tag
+#define BINKMARKER3 'hKIB' // newer Bink files use this tag
+#define BINKMARKER4 'iKIB' // even newer Bink files use this tag
+
+typedef struct BINKHDR
+{
+    u32 Marker; // Bink marker
+    u32 Size; // size of the file-8
+    u32 Frames; // Number of frames (1 based, 100 = 100 frames)
+    u32 LargestFrameSize; // Size in bytes of largest frame
+    u32 InternalFrames; // Number of internal frames
+
+    u32 Width; // Width (1 based, 640 for example)
+    u32 Height; // Height (1 based, 480 for example)
+    u32 FrameRate; // frame rate
+    u32 FrameRateDiv; // frame rate divisor (framerate/frameratediv=fps)
+
+    u32 Flags; // height compression options
+    u32 NumTracks; // number of tracks
+} BINKHDR;
+
+//=======================================================================
+#define BINKYAINVERT 0x00000800L // Reverse Y and A planes when blitting (for debugging)
+#define BINKFRAMERATE 0x00001000L // Override fr (call BinkFrameRate first)
+#define BINKPRELOADALL 0x00002000L // Preload the entire animation
+#define BINKSNDTRACK 0x00004000L // Set the track number to play
+#define BINKOLDFRAMEFORMAT 0x00008000L // using the old Bink frame format (internal use only)
+#define BINKRBINVERT 0x00010000L // use reversed R and B planes (internal use only)
+#define BINKGRAYSCALE 0x00020000L // Force Bink to use grayscale
+#define BINKNOMMX 0x00040000L // Don't use MMX
+#define BINKNOSKIP 0x00080000L // Don't skip frames if falling behind
+#define BINKALPHA 0x00100000L // Decompress alpha plane (if present)
+#define BINKNOFILLIOBUF 0x00200000L // Fill the IO buffer in SmackOpen
+#define BINKSIMULATE 0x00400000L // Simulate the speed (call BinkSim first)
+#define BINKFILEHANDLE 0x00800000L // Use when passing in a file handle
+#define BINKIOSIZE 0x01000000L // Set an io size (call BinkIOSize first)
+#define BINKIOPROCESSOR 0x02000000L // Set an io processor (call BinkIO first)
+#define BINKFROMMEMORY 0x04000000L // Use when passing in a pointer to the file
+#define BINKNOTHREADEDIO 0x08000000L // Don't use a background thread for IO
+
+#define BINKSURFACEFAST 0x00000000L
+#define BINKSURFACESLOW 0x08000000L
+#define BINKSURFACEDIRECT 0x04000000L
+
+#define BINKCOPYALL 0x80000000L // copy all pixels (not just changed)
+#define BINKCOPY2XH 0x10000000L // Force doubling height scaling
+#define BINKCOPY2XHI 0x20000000L // Force interleaving height scaling
+#define BINKCOPY2XW 0x30000000L // copy the width zoomed by two
+#define BINKCOPY2XWH 0x40000000L // copy the width and height zoomed by two
+#define BINKCOPY2XWHI 0x50000000L // copy the width and height zoomed by two
+#define BINKCOPY1XI 0x60000000L // copy the width and height zoomed by two
+#define BINKCOPYNOSCALING 0x70000000L // Force scaling off
+
+//#define BINKALPHA           0x00100000L // Decompress alpha plane (if present)
+//#define BINKNOSKIP          0x00080000L // don't skip the blit if behind in sound
+//#define BINKNOMMX           0x00040000L // Don't skip frames if falling behind
+//#define BINKGRAYSCALE       0x00020000L // force Bink to use grayscale
+//#define BINKRBINVERT        0x00010000L // use reversed R and B planes
+
+#define BINKSURFACE8P 0
+#define BINKSURFACE24 1
+#define BINKSURFACE24R 2
+#define BINKSURFACE32 3
+#define BINKSURFACE32R 4
+#define BINKSURFACE32A 5
+#define BINKSURFACE32RA 6
+#define BINKSURFACE4444 7
+#define BINKSURFACE5551 8
+#define BINKSURFACE555 9
+#define BINKSURFACE565 10
+#define BINKSURFACE655 11
+#define BINKSURFACE664 12
+#define BINKSURFACEYUY2 13
+#define BINKSURFACEUYVY 14
+#define BINKSURFACEYV12 15
+#define BINKSURFACEMASK 15
+
+#ifdef __RADXBOX__
+
+#define BINKSURFACESALL 32
+#define BINKCONVERTERSMONO 64
+#define BINKCONVERTERS2X 256
+
+#define BINKCONVERTERSALL (BINKSURFACESALL | BINKCONVERTERSMONO | BINKCONVERTERS2X)
+
+#define BinkLoad() BinkLoadUnload(1)
+#define BinkUnload() BinkLoadUnload(0)
+
+#define BinkLoadConverter(val) BinkLoadUnloadConverter(val, 1)
+#define BinkUnloadConverter(val) BinkLoadUnloadConverter(val, 0)
+
+RADEXPFUNC void RADEXPLINK BinkLoadUnload(s32 inout);
+RADEXPFUNC void RADEXPLINK BinkLoadUnloadConverter(u32 surfaces, s32 inout);
+
+#endif
+
+#define BINKGOTOQUICK 1
+#define BINKGOTOQUICKSOUND 2
+
+#define BINKGETKEYPREVIOUS 0
+#define BINKGETKEYNEXT 1
+#define BINKGETKEYCLOSEST 2
+#define BINKGETKEYNOTEQUAL 128
+
+//=======================================================================
+
+#ifdef __RADMAC__
+#pragma export on
+
+RADEXPFUNC HBINK RADEXPLINK BinkMacOpen(void /*FSSpec*/* fsp, u32 flags);
+#endif
+
+RADEXPFUNC void PTR4* RADEXPLINK BinkLogoAddress(void);
+
+RADEXPFUNC void RADEXPLINK BinkSetError(const char PTR4* err);
+RADEXPFUNC char PTR4* RADEXPLINK BinkGetError(void);
+
+RADEXPFUNC HBINK RADEXPLINK BinkOpen(const char PTR4* name, u32 flags);
+
+RADEXPFUNC s32 RADEXPLINK BinkDoFrame(HBINK bnk);
+RADEXPFUNC void RADEXPLINK BinkNextFrame(HBINK bnk);
+RADEXPFUNC s32 RADEXPLINK BinkWait(HBINK bnk);
+RADEXPFUNC void RADEXPLINK BinkClose(HBINK bnk);
+RADEXPFUNC s32 RADEXPLINK BinkPause(HBINK bnk, s32 pause);
+RADEXPFUNC s32 RADEXPLINK BinkCopyToBuffer(HBINK bnk, void* dest, s32 destpitch, u32 destheight,
+                                           u32 destx, u32 desty, u32 flags);
+RADEXPFUNC s32 RADEXPLINK BinkCopyToBufferRect(HBINK bnk, void* dest, s32 destpitch, u32 destheight,
+                                               u32 destx, u32 desty, u32 srcx, u32 srcy, u32 srcw,
+                                               u32 srch, u32 flags);
+RADEXPFUNC s32 RADEXPLINK BinkGetRects(HBINK bnk, u32 flags);
+RADEXPFUNC void RADEXPLINK BinkGoto(HBINK bnk, u32 frame, s32 flags); // use 1 for the first frame
+RADEXPFUNC u32 RADEXPLINK BinkGetKeyFrame(HBINK bnk, u32 frame, s32 flags);
+
+RADEXPFUNC s32 RADEXPLINK BinkSetVideoOnOff(HBINK bnk, s32 onoff);
+RADEXPFUNC s32 RADEXPLINK BinkSetSoundOnOff(HBINK bnk, s32 onoff);
+RADEXPFUNC void RADEXPLINK BinkFreeGlocalMemory(void);
+RADEXPFUNC void RADEXPLINK BinkSetVolume(HBINK bnk, u32 trackid, s32 volume);
+RADEXPFUNC void RADEXPLINK BinkSetPan(HBINK bnk, u32 trackid, s32 pan);
+RADEXPFUNC void RADEXPLINK BinkSetMixBins(HBINK bnk, u32 trackid, u32 PTR4* mix_bins, u32 total);
+RADEXPFUNC void RADEXPLINK BinkSetMixBinVolumes(HBINK bnk, u32 trackid, u32 PTR4* vol_mix_bins,
+                                                s32 PTR4* volumes, u32 total);
+RADEXPFUNC void RADEXPLINK BinkService(HBINK bink);
+
+typedef struct BINKTRACK PTR4* HBINKTRACK;
+
+typedef struct BINKTRACK
+{
+    u32 Frequency;
+    u32 Bits;
+    u32 Channels;
+    u32 MaxSize;
+
+    HBINK bink;
+    u32 sndcomp;
+    s32 trackindex;
+} BINKTRACK;
+
+RADEXPFUNC HBINKTRACK RADEXPLINK BinkOpenTrack(HBINK bnk, u32 trackindex);
+RADEXPFUNC void RADEXPLINK BinkCloseTrack(HBINKTRACK bnkt);
+RADEXPFUNC u32 RADEXPLINK BinkGetTrackData(HBINKTRACK bnkt, void PTR4* dest);
+
+RADEXPFUNC u32 RADEXPLINK BinkGetTrackType(HBINK bnk, u32 trackindex);
+RADEXPFUNC u32 RADEXPLINK BinkGetTrackMaxSize(HBINK bnk, u32 trackindex);
+RADEXPFUNC u32 RADEXPLINK BinkGetTrackID(HBINK bnk, u32 trackindex);
+
+RADEXPFUNC void RADEXPLINK BinkGetSummary(HBINK bnk, BINKSUMMARY PTR4* sum);
+RADEXPFUNC void RADEXPLINK BinkGetRealtime(HBINK bink, BINKREALTIME PTR4* run, u32 frames);
+
+RADEXPFUNC void RADEXPLINK BinkSetSoundTrack(u32 total_tracks, u32 PTR4* tracks);
+RADEXPFUNC void RADEXPLINK BinkSetIO(BINKIOOPEN io);
+RADEXPFUNC void RADEXPLINK BinkSetFrameRate(u32 forcerate, u32 forceratediv);
+RADEXPFUNC void RADEXPLINK BinkSetSimulate(u32 sim);
+RADEXPFUNC void RADEXPLINK BinkSetIOSize(u32 iosize);
+
+RADEXPFUNC s32 RADEXPLINK BinkSetSoundSystem(BINKSNDSYSOPEN open, u32 param);
+
+#ifdef __RADWIN__
+
+RADEXPFUNC BINKSNDOPEN RADEXPLINK BinkOpenDirectSound(u32 param); // don't call directly
+#define BinkSoundUseDirectSound(lpDS) BinkSetSoundSystem(BinkOpenDirectSound, (u32)lpDS)
+
+RADEXPFUNC BINKSNDOPEN RADEXPLINK BinkOpenWaveOut(u32 param); // don't call directly
+#define BinkSoundUseWaveOut() BinkSetSoundSystem(BinkOpenWaveOut, 0)
+
+#endif
+
+#ifndef __RADMAC__
+
+RADEXPFUNC BINKSNDOPEN RADEXPLINK BinkOpenMiles(u32 param); // don't call directly
+#define BinkSoundUseMiles(hdigdriver) BinkSetSoundSystem(BinkOpenMiles, (u32)hdigdriver)
+
+#endif
+
+#ifdef __RADMAC__
+
+RADEXPFUNC BINKSNDOPEN RADEXPLINK BinkOpenSoundManager(u32 param); // don't call directly
+#define BinkSoundUseSoundManager() BinkSetSoundSystem(BinkOpenSoundManager, 0)
+
+#endif
+
+#ifdef __RADLINUX__
+
+RADEXPFUNC BINKSNDOPEN RADEXPLINK BinkOpenSDLMixer(u32 param); // don't call directly
+#define BinkSoundUseSDLMixer() BinkSetSoundSystem(BinkOpenSDLMixer, 0)
+
+#endif
+
+#ifdef __RADNGC__
+
+typedef void PTR4*(RADLINK PTR4* RADARAMALLOC)(u32 num_bytes);
+typedef void(RADLINK PTR4* RADARAMFREE)(void PTR4* ptr);
+
+typedef struct RADARAMCALLBACKS
+{
+    RADARAMALLOC aram_malloc;
+    RADARAMFREE aram_free;
+} RADARAMCALLBACKS;
+
+RADEXPFUNC BINKSNDOPEN RADEXPLINK BinkOpenAX(u32 param); // don't call directly
+#define BinkSoundUseAX(functions)                                                                  \
+    BinkSetSoundSystem(BinkOpenAX, (u32)functions) // takes a pointer to RADARAMCALLBACKS
+
+RADEXPFUNC BINKSNDOPEN RADEXPLINK BinkOpenMusyXSound(u32 param); // don't call directly
+#define BinkSoundUseMusyX() BinkSetSoundSystem(BinkOpenMusyXSound, 0)
+
+#endif
+
+#if defined(__RADXBOX__) || defined(__RADWIN__)
+
+RADEXPFUNC s32 RADEXPLINK BinkDX8SurfaceType(void* lpD3Ds);
+
+#endif
+
+#if defined(__RADWIN__)
+
+RADEXPFUNC s32 RADEXPLINK BinkDX9SurfaceType(void* lpD3Ds);
+
+#endif
+
+// The BinkBuffer API isn't implemented on DOS, Xbox or GameCube
+#if !defined(__RADDOS__) && !defined(__RADXBOX__) && !defined(__RADNGC__)
+
+//=========================================================================
+typedef struct BINKBUFFER* HBINKBUFFER;
+
+#define BINKBUFFERSTRETCHXINT 0x80000000
+#define BINKBUFFERSTRETCHX 0x40000000
+#define BINKBUFFERSHRINKXINT 0x20000000
+#define BINKBUFFERSHRINKX 0x10000000
+#define BINKBUFFERSTRETCHYINT 0x08000000
+#define BINKBUFFERSTRETCHY 0x04000000
+#define BINKBUFFERSHRINKYINT 0x02000000
+#define BINKBUFFERSHRINKY 0x01000000
+#define BINKBUFFERSCALES 0xff000000
+#define BINKBUFFERRESOLUTION 0x00800000
+
+#ifdef __RADMAC__
+
+//#include <windows.h>
+//#include <palettes.h>
+//#include <qdoffscreen.h>
+
+typedef struct BINKBUFFER
+{
+    u32 Width;
+    u32 Height;
+    u32 WindowWidth;
+    u32 WindowHeight;
+    u32 SurfaceType;
+    void* Buffer;
+    s32 BufferPitch;
+    u32 ScreenWidth;
+    u32 ScreenHeight;
+    u32 ScreenDepth;
+    u32 ScaleFlags;
+
+    s32 destx, desty;
+    s32 wndx, wndy;
+    u32 wnd;
+
+    s32 noclipping;
+    u32 type;
+    s32 issoftcur;
+    u32 cursorcount;
+
+} BINKBUFFER;
+
+#define BINKBUFFERAUTO 0
+#define BINKBUFFERDIRECT 1
+#define BINKBUFFERGWORLD 2
+#define BINKBUFFERTYPEMASK 31
+
+RADEXPFUNC HBINKBUFFER RADEXPLINK BinkBufferOpen(void* /*WindowPtr*/ wnd, u32 width, u32 height,
+                                                 u32 bufferflags);
+RADEXPFUNC s32 RADEXPLINK BinkGDSurfaceType(void* /*GDHandle*/ gd);
+RADEXPFUNC s32 RADEXPLINK BinkIsSoftwareCursor(void* /*GDHandle*/ gd);
+RADEXPFUNC s32 RADEXPLINK BinkCheckCursor(void* /*WindowPtr*/ wp, s32 x, s32 y, s32 w, s32 h);
+
+#else
+
+typedef struct BINKBUFFER
+{
+    u32 Width;
+    u32 Height;
+    u32 WindowWidth;
+    u32 WindowHeight;
+    u32 SurfaceType;
+    void* Buffer;
+    s32 BufferPitch;
+    s32 ClientOffsetX;
+    s32 ClientOffsetY;
+    u32 ScreenWidth;
+    u32 ScreenHeight;
+    u32 ScreenDepth;
+    u32 ExtraWindowWidth;
+    u32 ExtraWindowHeight;
+    u32 ScaleFlags;
+    u32 StretchWidth;
+    u32 StretchHeight;
+
+    s32 surface;
+    void* ddsurface;
+    void* ddclipper;
+    s32 destx, desty;
+    s32 wndx, wndy;
+    u32 wnd;
+    s32 minimized;
+    s32 ddoverlay;
+    s32 ddoffscreen;
+    s32 lastovershow;
+
+    s32 issoftcur;
+    u32 cursorcount;
+    void* buffertop;
+    u32 type;
+    s32 noclipping;
+
+    s32 loadeddd;
+    s32 loadedwin;
+
+    void* dibh;
+    void* dibbuffer;
+    s32 dibpitch;
+    void* dibinfo;
+    u32 dibdc;
+    u32 diboldbitmap;
+
+} BINKBUFFER;
+
+#define BINKBUFFERAUTO 0
+#define BINKBUFFERPRIMARY 1
+#define BINKBUFFERDIBSECTION 2
+#define BINKBUFFERYV12OVERLAY 3
+#define BINKBUFFERYUY2OVERLAY 4
+#define BINKBUFFERUYVYOVERLAY 5
+#define BINKBUFFERYV12OFFSCREEN 6
+#define BINKBUFFERYUY2OFFSCREEN 7
+#define BINKBUFFERUYVYOFFSCREEN 8
+#define BINKBUFFERRGBOFFSCREENVIDEO 9
+#define BINKBUFFERRGBOFFSCREENSYSTEM 10
+#define BINKBUFFERLAST 10
+#define BINKBUFFERTYPEMASK 31
+
+RADEXPFUNC HBINKBUFFER RADEXPLINK BinkBufferOpen(void* /*HWND*/ wnd, u32 width, u32 height,
+                                                 u32 bufferflags);
+RADEXPFUNC s32 RADEXPLINK BinkBufferSetHWND(HBINKBUFFER buf, void* /*HWND*/ newwnd);
+RADEXPFUNC s32 RADEXPLINK BinkDDSurfaceType(void PTR4* lpDDS);
+RADEXPFUNC s32 RADEXPLINK BinkIsSoftwareCursor(void PTR4* lpDDSP, void* /*HCURSOR*/ cur);
+RADEXPFUNC s32 RADEXPLINK BinkCheckCursor(void* /*HWND*/ wnd, s32 x, s32 y, s32 w, s32 h);
+RADEXPFUNC s32 RADEXPLINK BinkBufferSetDirectDraw(void PTR4* lpDirectDraw, void PTR4* lpPrimary);
+
+#endif
+
+RADEXPFUNC void RADEXPLINK BinkBufferClose(HBINKBUFFER buf);
+RADEXPFUNC s32 RADEXPLINK BinkBufferLock(HBINKBUFFER buf);
+RADEXPFUNC s32 RADEXPLINK BinkBufferUnlock(HBINKBUFFER buf);
+RADEXPFUNC void RADEXPLINK BinkBufferSetResolution(s32 w, s32 h, s32 bits);
+RADEXPFUNC void RADEXPLINK BinkBufferCheckWinPos(HBINKBUFFER buf, s32 PTR4* NewWindowX,
+                                                 s32 PTR4* NewWindowY);
+RADEXPFUNC s32 RADEXPLINK BinkBufferSetOffset(HBINKBUFFER buf, s32 destx, s32 desty);
+RADEXPFUNC void RADEXPLINK BinkBufferBlit(HBINKBUFFER buf, BINKRECT PTR4* rects, u32 numrects);
+RADEXPFUNC s32 RADEXPLINK BinkBufferSetScale(HBINKBUFFER buf, u32 w, u32 h);
+RADEXPFUNC char PTR4* RADEXPLINK BinkBufferGetDescription(HBINKBUFFER buf);
+RADEXPFUNC char PTR4* RADEXPLINK BinkBufferGetError();
+RADEXPFUNC void RADEXPLINK BinkRestoreCursor(s32 checkcount);
+RADEXPFUNC s32 RADEXPLINK BinkBufferClear(HBINKBUFFER buf, u32 RGB);
+
+#endif
+
+typedef void PTR4*(RADLINK PTR4* BINKMEMALLOC)(u32 bytes);
+typedef void(RADLINK PTR4* BINKMEMFREE)(void PTR4* ptr);
+
+RADEXPFUNC void RADEXPLINK BinkSetMemory(BINKMEMALLOC a, BINKMEMFREE f);
+
+#ifdef __RADMAC__
+
+#pragma export off
+
+#endif
+
+RADDEFEND
+
+#endif
+
+// @cdep pre $set(INCs,$INCs -I$clipfilename($file)) $ignore(TakeCPP)
+
+#endif
diff --git a/src/bink/include/binkngc.h b/src/bink/include/binkngc.h
new file mode 100644
index 000000000..e6870606b
--- /dev/null
+++ b/src/bink/include/binkngc.h
@@ -0,0 +1,8 @@
+#ifndef BINKNGC_H
+#define BINKNGC_H
+
+#include "bink.h"
+
+void radfree(void* ptr);
+
+#endif
diff --git a/src/bink/include/binkread.h b/src/bink/include/binkread.h
new file mode 100644
index 000000000..98a8c47c0
--- /dev/null
+++ b/src/bink/include/binkread.h
@@ -0,0 +1,6 @@
+#ifndef BINKREAD_H
+#define BINKREAD_H
+
+#include "bink.h"
+
+#endif
diff --git a/src/bink/include/popmal.h b/src/bink/include/popmal.h
index 230bc03ae..527d08d61 100644
--- a/src/bink/include/popmal.h
+++ b/src/bink/include/popmal.h
@@ -1,6 +1,9 @@
 #ifndef POPMAL_H
 #define POPMAL_H
 
-#include "types.h"
+#include "bink.h"
+
+u32 popmalloctotal();
+u32 popmalloc(HBINK bnk);
 
 #endif
diff --git a/src/bink/include/rad3d.h b/src/bink/include/rad3d.h
new file mode 100644
index 000000000..e13581f5b
--- /dev/null
+++ b/src/bink/include/rad3d.h
@@ -0,0 +1,128 @@
+#ifndef __RAD3DH__
+#define __RAD3DH__
+
+#ifndef __RADBASEH__
+#include "radbase.h"
+#endif
+
+#ifdef GEKKO
+
+#define RAD3DSURFACE32 0
+#define RAD3DSURFACE32A 1
+#define RAD3DSURFACE565 2
+#define RAD3DSURFACE4444 3 // actually RGB4A3
+#define RADSURFACEYUY2 4
+#define RAD3DSURFACECOUNT (RADSURFACEYUY2 + 1)
+
+#else
+
+#define RAD3DSURFACE32 0
+#define RAD3DSURFACE32A 1
+#define RAD3DSURFACE555 2
+#define RAD3DSURFACE565 3
+#define RAD3DSURFACE5551 4
+#define RAD3DSURFACE4444 5
+
+#ifdef _XBOX
+#define RAD3DSURFACEYUY2 6
+#define RAD3DSURFACECOUNT (RAD3DSURFACEYUY2 + 1)
+#else
+#define RAD3DSURFACE32R 6
+#define RAD3DSURFACE32RA 7
+#define RAD3DSURFACE24 8
+#define RAD3DSURFACE24R 9
+#define RAD3DSURFACECOUNT (RAD3DSURFACE24R + 1)
+#endif
+
+#endif
+
+#ifdef __cplusplus
+#define RADCFUNC extern "C"
+#else
+#define RADCFUNC
+#endif
+
+#ifdef GEKKO
+
+#define HRAD3D int
+
+#elif _XBOX
+
+#define HRAD3D LPDIRECT3DDEVICE8
+
+#else
+
+//
+// Define the handle types.
+//
+
+struct RAD3D;
+typedef struct RAD3D* HRAD3D;
+
+//
+// Functions to open a RAD 3D handle (to OpenGL or Direct3D).
+//
+
+typedef void* HWND;
+
+RADCFUNC HRAD3D Open_RAD_3D(HWND window);
+
+RADCFUNC void Close_RAD_3D(HRAD3D rad_3D);
+
+RADCFUNC void Resize_RAD_3D(HRAD3D rad_3d, U32 width, U32 height);
+
+RADCFUNC char* Describe_RAD_3D(void);
+
+#endif
+
+RADCFUNC void Start_RAD_3D_frame(HRAD3D rad_3D);
+
+RADCFUNC void End_RAD_3D_frame(HRAD3D rad_3D
+#ifdef GEKKO
+                               ,
+                               S32 swap
+#endif
+);
+
+//
+// Define the handle types.
+//
+
+struct RAD3DIMAGE;
+typedef struct RAD3DIMAGE* HRAD3DIMAGE;
+
+//
+// Functions to open a 3D image handle (GL or D3D texture array).
+//
+
+RADCFUNC HRAD3DIMAGE Open_RAD_3D_image(HRAD3D rad_3d, U32 width, U32 height,
+#if defined(_XBOX) || defined(GEKKO)
+                                       U32 rad3d_surface_format
+#else
+                                       S32 alpha_pixels, U32 maximum_texture_size RADDEFAULT(256)
+#endif
+);
+
+RADCFUNC void Close_RAD_3D_image(HRAD3DIMAGE rad_image);
+
+// RADCFUNC S32 Lock_RAD_3D_image(HRAD3DIMAGE rad_image, void* out_pixel_buffer, U32* out_buffer_pitch,
+//                                U32* out_surface_type
+
+// #if !(defined(_XBOX) || defined(GEKKO))
+//                                ,
+//                                U32* src_x, U32* src_y, U32* src_w, U32* src_h
+// #endif
+// );
+
+RADCFUNC S32 Lock_RAD_3D_image(HRAD3DIMAGE rad_image, void* out_pixel_buffer, U32* out_buffer_pitch,
+                               U32* arg3);
+
+RADCFUNC void Unlock_RAD_3D_image(HRAD3DIMAGE rad_image);
+
+RADCFUNC void Blit_RAD_3D_image(HRAD3DIMAGE rad_image, F32 x_offset, F32 y_offset, F32 x_scale,
+                                F32 y_scale, F32 alpha_level);
+
+RADCFUNC void Draw_lines_RAD_3D_image(HRAD3DIMAGE rad_image, F32 x_offset, F32 y_offset,
+                                      F32 x_scale, F32 y_scale);
+
+#endif
diff --git a/src/bink/include/radbase.h b/src/bink/include/radbase.h
new file mode 100644
index 000000000..e98456921
--- /dev/null
+++ b/src/bink/include/radbase.h
@@ -0,0 +1,399 @@
+//  __RAD16__ means 16 bit code (Win16)
+//  __RAD32__ means 32 bit code (DOS, Win386, Win32s, Mac)
+
+//  __RADDOS__ means DOS code (16 or 32 bit)
+//  __RADWIN__ means Windows code (Win16, Win386, Win32s)
+//  __RADWINEXT__ means Windows 386 extender (Win386)
+//  __RADNT__ means Win32s code
+//  __RADMAC__ means Macintosh
+//  __RADCARBON__ means Carbon
+//  __RADMACH__ means MachO
+//  __RADXBOX__ means the XBox console
+//  __RADNGC__ means the Nintendo GameCube
+//  __RADNTBUILDLINUX__ means building Linux on NT
+//  __RADLINUX__ means actually building on Linux (most likely with GCC)
+
+//  __RADX86__ means Intel x86
+//  __RADMMX__ means Intel x86 MMX instructions are allowed
+//  __RAD68K__ means 68K
+//  __RADPPC__ means PowerPC
+
+// __RADLITTLEENDIAN__ means processor is little-endian (x86)
+// __RADBIGENDIAN__ means processor is big-endian (680x0, PPC)
+
+#ifndef __RADBASEH__
+#define __RADBASEH__
+
+#define RADCOPYRIGHT "Copyright (C) 1994-2003, RAD Game Tools, Inc."
+
+#ifndef __RADRES__
+
+#define __RADNGC__
+#define __RAD32__
+#define __RADPPC__
+#define __RADBIGENDIAN__
+
+#if defined(GEKKO)
+
+#define __RADNGC__
+#define __RAD32__
+#define __RADPPC__
+#define __RADBIGENDIAN__
+#define RADINLINE inline
+
+#elif (defined(__MWERKS__) && !defined(__INTEL__)) || defined(__MRC__) || defined(THINK_C) ||      \
+    defined(powerc) || defined(macintosh) || defined(__powerc) || defined(__APPLE__) ||            \
+    defined(__MACH__)
+#define __RADMAC__
+#if defined(powerc) || defined(__powerc) || defined(__ppc__)
+#define __RADPPC__
+#else
+#define __RAD68K__
+#endif
+
+#define __RAD32__
+#define __RADBIGENDIAN__
+
+#if defined(__MWERKS__)
+#if (defined(__cplusplus) || !__option(only_std_keywords))
+#define RADINLINE inline
+#endif
+#elif defined(__MRC__)
+#if defined(__cplusplus)
+#define RADINLINE inline
+#endif
+#elif defined(__GNUC__) || defined(__GNUG__)
+#define RADINLINE inline
+#define __RADMACH__
+#endif
+
+#ifdef __MACH__
+#define __RADMACH__
+#endif
+
+#ifdef TARGET_API_MAC_CARBON
+#if TARGET_API_MAC_CARBON
+#ifndef __RADCARBON__
+#define __RADCARBON__
+#endif
+#endif
+#endif
+
+#elif defined(linux)
+
+#define __RADLINUX__
+#define __RADX86__
+#define __RADMMX__
+#define __RAD32__
+#define __RADLITTLEENDIAN__
+#define RADINLINE inline
+
+#else
+
+#define __RADX86__
+#define __RADMMX__
+
+#ifdef __MWERKS__
+#define _WIN32
+#endif
+
+#ifdef __DOS__
+#define __RADDOS__
+#endif
+
+#ifdef __386__
+#define __RAD32__
+#endif
+
+#ifdef _Windows //For Borland
+#ifdef __WIN32__
+#define WIN32
+#else
+#define __WINDOWS__
+#endif
+#endif
+
+#ifdef _WINDOWS //For MS
+#ifndef _WIN32
+#define __WINDOWS__
+#endif
+#endif
+
+#ifdef _WIN32
+#ifdef _XBOX
+#define __RADXBOX__
+#else
+#define __RADNT__
+#endif
+#define __RADWIN__
+#define __RAD32__
+#else
+#ifdef __NT__
+#ifdef _XBOX
+#define __RADXBOX__
+#else
+#define __RADNT__
+#endif
+#define __RADWIN__
+#define __RAD32__
+#else
+#ifdef __WINDOWS_386__
+#define __RADWIN__
+#define __RADWINEXT__
+#define __RAD32__
+#else
+#ifdef __WINDOWS__
+#define __RADWIN__
+#define __RAD16__
+#else
+#ifdef WIN32
+#ifdef _XBOX
+#define __RADXBOX__
+#else
+#define __RADNT__
+#endif
+#define __RADWIN__
+#define __RAD32__
+#endif
+#endif
+#endif
+#endif
+#endif
+
+#define __RADLITTLEENDIAN__
+#ifdef __WATCOMC__
+#define RADINLINE
+#else
+#define RADINLINE __inline
+#endif
+#endif
+
+#if (!defined(__RADDOS__) && !defined(__RADWIN__) && !defined(__RADMAC__) &&                       \
+     !defined(__RADNGC__) && !defined(__RADXBOX__) && !defined(__RADLINUX__))
+#error                                                                                             \
+    "RAD.H did not detect your platform.  Define __DOS__, __WINDOWS__, WIN32, macintosh, or powerc."
+#endif
+
+#ifdef __RADFINAL__
+#define RADTODO(str)                                                                               \
+    {                                                                                              \
+        char __str[0] = str;                                                                       \
+    }
+#else
+#define RADTODO(str)
+#endif
+
+#ifdef __RADNGC__
+
+#define RADLINK
+#define RADEXPLINK
+#define RADEXPFUNC RADDEFFUNC
+#define RADASMLINK
+#define PTR4
+
+#elif defined(__RADLINUX__)
+
+#define RADLINK __attribute__((cdecl))
+#define RADEXPLINK __attribute__((cdecl))
+#define RADEXPFUNC RADDEFFUNC
+#define RADASMLINK
+#define PTR4
+
+#elif defined(__RADMAC__)
+
+// this define is for CodeWarrior 11's stupid new libs (even though
+//   we don't use longlong's).
+
+#define __MSL_LONGLONG_SUPPORT__
+
+#define RADLINK
+#define RADEXPLINK
+
+#ifdef __CFM68K__
+#ifdef __RADINDLL__
+#define RADEXPFUNC RADDEFFUNC __declspec(export)
+#else
+#define RADEXPFUNC RADDEFFUNC __declspec(import)
+#endif
+#else
+#define RADEXPFUNC RADDEFFUNC
+#endif
+#define RADASMLINK
+
+#else
+
+#ifdef __RADNT__
+#ifndef _WIN32
+#define _WIN32
+#endif
+#ifndef WIN32
+#define WIN32
+#endif
+#endif
+
+#ifdef __RADWIN__
+#ifdef __RAD32__
+#ifdef __RADXBOX__
+
+#define RADLINK __stdcall
+#define RADEXPLINK __stdcall
+#define RADEXPFUNC RADDEFFUNC
+
+#elif defined(__RADNTBUILDLINUX__)
+
+#define RADLINK __cdecl
+#define RADEXPLINK __cdecl
+#define RADEXPFUNC RADDEFFUNC
+
+#else
+#ifdef __RADNT__
+
+#define RADLINK __stdcall
+#define RADEXPLINK __stdcall
+
+#ifdef __RADINEXE__
+#define RADEXPFUNC RADDEFFUNC
+#else
+#ifndef __RADINDLL__
+#define RADEXPFUNC RADDEFFUNC __declspec(dllimport)
+#ifdef __BORLANDC__
+#if __BORLANDC__ <= 0x460
+#undef RADEXPFUNC
+#define RADEXPFUNC RADDEFFUNC
+#endif
+#endif
+#else
+#define RADEXPFUNC RADDEFFUNC __declspec(dllexport)
+#endif
+#endif
+#else
+#define RADLINK __pascal
+#define RADEXPLINK __far __pascal
+#define RADEXPFUNC RADDEFFUNC
+#endif
+#endif
+#else
+#define RADLINK __pascal
+#define RADEXPLINK __far __pascal __export
+#define RADEXPFUNC RADDEFFUNC
+#endif
+#else
+#define RADLINK __pascal
+#define RADEXPLINK __pascal
+#define RADEXPFUNC RADDEFFUNC
+#endif
+
+#define RADASMLINK __cdecl
+
+#endif
+
+#ifndef __RADXBOX__
+#ifdef __RADWIN__
+#ifndef _WINDOWS
+#define _WINDOWS
+#endif
+#endif
+#endif
+
+#ifndef RADDEFFUNC
+
+#ifdef __cplusplus
+#define RADDEFFUNC extern "C"
+#define RADDEFSTART extern "C" {
+#define RADDEFEND }
+#define RADDEFINEDATA extern "C"
+#define RADDECLAREDATA extern "C"
+#define RADDEFAULT(val) = val
+#else
+#define RADDEFFUNC
+#define RADDEFSTART
+#define RADDEFEND
+#define RADDEFINEDATA
+#define RADDECLAREDATA extern
+#define RADDEFAULT(val)
+#endif
+
+#endif
+
+#ifdef __RADNGC__
+#define RAD_ATTRIBUTE_ALIGN(num) __attribute__((aligned(num)))
+#else
+#ifdef __RADX86__
+#ifdef __WATCOMC__
+#define RAD_ATTRIBUTE_ALIGN(num)
+#else
+#define RAD_ATTRIBUTE_ALIGN(num) __declspec(align(num))
+#endif
+#else
+#define RAD_ATTRIBUTE_ALIGN(num)
+#endif
+#endif
+
+#ifdef __RADX86__
+#ifdef __WATCOMC__
+#define RAD_ALIGN_TYPE double
+#define RAD_ALIGN_DEF 0.0
+#else
+#define RAD_ALIGN_TYPE double __declspec(align(8))
+#define RAD_ALIGN_DEF 0.0
+#endif
+#else
+#define RAD_ALIGN_TYPE double
+#define RAD_ALIGN_DEF 0.0
+#endif
+
+#define RAD_ALIGN_ADD_TYPE(var) RAD_ALIGN_TYPE var##align = RAD_ALIGN_DEF
+
+// Each commented out line is required for our build
+
+// #define S8 signed char
+// #define U8 unsigned char
+// #define U32 unsigned long
+// #define S32 signed long
+// #define F32 float
+// #define F64 double
+
+#if defined(__MWERKS__) || defined(__MRC__) || defined(GEKKO)
+// #define U64 unsigned long long
+// #define S64 signed long long
+// #else
+// #define U64 unsigned __int64
+// #define S64 signed __int64
+#endif
+
+#ifdef __RAD32__
+#define PTR4
+#define U16 unsigned short
+#define S16 signed short
+#else
+#define PTR4 __far
+#define U16 unsigned int
+#define S16 signed int
+#endif
+
+#ifndef RAD_NO_LOWERCASE_TYPES
+
+#ifdef __RADNGC__
+
+#include <dolphin/types.h>
+
+#else
+
+#define u8 U8
+#define s8 S8
+#define u16 U16
+#define s16 S16
+#define u32 U32
+#define s32 S32
+#define u64 U64
+#define s64 S64
+#define f32 F32
+#define f64 F64
+
+#endif
+
+#endif
+
+#endif
+
+#endif
diff --git a/src/bink/include/radcb.h b/src/bink/include/radcb.h
new file mode 100644
index 000000000..853e3fa00
--- /dev/null
+++ b/src/bink/include/radcb.h
@@ -0,0 +1,21 @@
+#ifndef RADCD_H
+#define RADCB_H
+
+#include "bink.h"
+
+void RADCB_unregister_2_callbacks(BINKIO* io);
+u32 RADCB_registered_count(BINKIO io);
+u32 RADCB_try_to_suspend_handler(BINKIO* io);
+void RADCB_suspend_handler(BINKIO* io);
+void RADCB_resume_handler(BINKIO* io);
+void RADCB_try_to_suspend_callback(HBINK bnk, HBINK bnk1);
+void RADCB_suspend_callback(HBINK bnk, HBINK bnk1);
+void RADCB_suspend_2_callbacks(BINKIO* io, BINKIO* io2, BINKIO* io3, BINKIO* io4);
+void RADCB_resume_callback(HBINK bnk, HBINK bnk1);
+void RADCB_suspend_2_handlers(BINKIO* io, BINKIO* io2);
+void RADCB_free_handler(RADARAMCALLBACKS* callback);
+void RADCB_free_2_handlers(BINKIO* io, BINKIO* io2);
+void RADCB_idle_on_callbacks();
+u32 RADCB_callback_size();
+
+#endif
diff --git a/src/bink/shared/time/radcb.c b/src/bink/shared/time/radcb.c
index e69de29bb..3756d01f2 100644
--- a/src/bink/shared/time/radcb.c
+++ b/src/bink/shared/time/radcb.c
@@ -0,0 +1,91 @@
+#include "binkngc.h"
+#include <dolphin/os/OSAlarm.h>
+
+void RADCB_unregister_2_callbacks(BINKIO* io)
+{
+}
+
+u32 RADCB_registered_count(BINKIO io)
+{
+    return io.ThreadTime;
+}
+
+u32 RADCB_try_to_suspend_handler(BINKIO* io)
+{
+}
+
+void RADCB_suspend_handler(BINKIO* io)
+{
+    while (!RADCB_try_to_suspend_handler(io))
+    {
+        OSYieldThread();
+    }
+}
+
+// TODO:
+// BINKIO* as the arg probably isnt right
+// io->callback_control is definitely wrong
+void RADCB_resume_handler(BINKIO* io)
+{
+    if (io != NULL)
+    {
+        OSDisableInterrupts();
+        io->callback_control[1] = io->callback_control[1] + -1;
+        if (io->callback_control[1] == 0)
+        {
+            io->ReadHeader = 1;
+        }
+        OSRestoreInterrupts();
+    }
+}
+
+void RADCB_try_to_suspend_callback(HBINK bnk, HBINK bnk1)
+{
+}
+
+// (int param_1,int param_2)
+void RADCB_suspend_callback(HBINK bnk, HBINK bnk1)
+{
+    return;
+}
+
+void RADCB_suspend_2_callbacks(BINKIO* io, BINKIO* io2, BINKIO* io3, BINKIO* io4)
+{
+    RADCB_suspend_callback(io, io2);
+    RADCB_suspend_callback(io3, io4);
+}
+
+void RADCB_resume_callback(HBINK bnk, HBINK bnk1)
+{
+}
+
+void RADCB_suspend_2_handlers(BINKIO* io, BINKIO* io2)
+{
+    RADCB_suspend_handler(io);
+    RADCB_suspend_handler(io2);
+}
+
+void RADCB_free_handler(RADARAMCALLBACKS* callback)
+{
+    if (callback != NULL)
+    {
+        RADCB_suspend_handler(callback);
+        OSCancelAlarm(callback + 1);
+        radfree(callback);
+    }
+}
+
+void RADCB_free_2_handlers(BINKIO* io, BINKIO* io2)
+{
+    RADCB_free_handler(io);
+    RADCB_free_handler(io2);
+}
+
+void RADCB_idle_on_callbacks()
+{
+}
+
+u32 RADCB_callback_size()
+{
+    return 28;
+}
diff --git a/src/bink/src/sdk/decode/binkread.c b/src/bink/src/sdk/decode/binkread.c
index e69de29bb..8233cfaad 100644
--- a/src/bink/src/sdk/decode/binkread.c
+++ b/src/bink/src/sdk/decode/binkread.c
@@ -0,0 +1,1015 @@
+#include "binkread.h"
+#include "radcb.h"
+#include "binkngc.h"
+
+static char binkerr[256];
+
+static u32 TrackNums = 0;
+u16 LogoData[0x1D00] = {
+
+    0x4249, 0x4B69, 0xF839, 0x0000, 0x0100, 0x0000, 0xCC39, 0x0000, 0x0100, 0x0000, 0xE000, 0x0000,
+    0xFC00, 0x0000, 0x0A00, 0x0000, 0x0100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x3500, 0x0000,
+    0x003A, 0x0000, 0xEC2B, 0x0000, 0xBE63, 0x15EC, 0x38C6, 0xB0CE, 0x702C, 0x6C80, 0x1E7D, 0x1243,
+    0xBE13, 0x4265, 0x9F14, 0x53A2, 0x5964, 0x31B3, 0x5176, 0xC4F4, 0x6187, 0xB9E5, 0xF478, 0x916E,
+    0xBCF4, 0x198E, 0x7ACD, 0xB3BE, 0xA19C, 0xB3BE, 0xAD1C, 0xB3CE, 0xD1BA, 0xF9CE, 0x3DBA, 0x49BE,
+    0xDEBC, 0x1A20, 0x9770, 0xE809, 0x1C43, 0x009A, 0x1F27, 0x03A1, 0x97EB, 0x42C4, 0x1188, 0x1010,
+    0x228E, 0x1084, 0x4042, 0x8488, 0x3842, 0x4412, 0x228E, 0x8084, 0x1010, 0x4188, 0x237E, 0xC40F,
+    0x026D, 0x1D71, 0xE929, 0xC4A1, 0xAF9E, 0xB645, 0x2171, 0xF4B4, 0xAD96, 0x2441, 0xD0D3, 0x16F4,
+    0xF54A, 0x1C81, 0x3ADA, 0x56D1, 0x4242, 0x46DA, 0x163D, 0x4516, 0x32F4, 0xB455, 0x42B2, 0x90D1,
+    0x5378, 0x95DA, 0x4216, 0xD0B6, 0x68B1, 0x856C, 0xA1A7, 0x2DB6, 0x856C, 0xD1B6, 0x506C, 0x0BD9,
+    0x9668, 0x69C9, 0xB690, 0x6DA1, 0x6D49, 0xB22D, 0x32E0, 0x7BC1, 0x5038, 0xA609, 0x0026, 0xA0A7,
+    0x7418, 0xFEFB, 0xC07A, 0x7906, 0x9840, 0x4A47, 0x9C13, 0x48E9, 0x8873, 0x0229, 0x1D71, 0x4E20,
+    0xA57A, 0x6D0D, 0x3BEF, 0xE4E7, 0xD576, 0xE498, 0xB136, 0x1CFB, 0xCEFE, 0x7424, 0x6002, 0x8509,
+    0x0026, 0x905F, 0xA543, 0x7FBD, 0xD876, 0x1F26, 0x90D2, 0x5DC4, 0x8909, 0x13F8, 0x3D9C, 0xC8F7,
+    0x6162, 0x2B2F, 0x9830, 0x6122, 0xFFF9, 0xF8EC, 0x7BD0, 0xDEDF, 0x730B, 0xE3BD, 0x708F, 0xF1AF,
+    0xE685, 0x7302, 0x403B, 0x1300, 0x4C00, 0x3801, 0x2762, 0x431E, 0x4CA4, 0x74A8, 0x714E, 0x20A5,
+    0x234E, 0x62F7, 0x98E7, 0xD4B7, 0x2313, 0x403A, 0xD261, 0xC044, 0x4A87, 0xB19B, 0x15F3, 0xFD26,
+    0x90D2, 0x1127, 0xC065, 0xC6B7, 0x7032, 0x01E0, 0x720F, 0xD03E, 0xEF75, 0xC044, 0x4E95, 0x0EF5,
+    0x0A9C, 0x1348, 0xE988, 0x7302, 0x29F5, 0xB0DD, 0xB311, 0x5757, 0x87FA, 0xAD72, 0x4E00, 0x3061,
+    0xC284, 0x0A13, 0x0080, 0x8D92, 0x2449, 0xF6AA, 0x378B, 0x927C, 0x5B8F, 0x5C96, 0x6444, 0x2439,
+    0xF25D, 0x23C8, 0xF36C, 0xAE1F, 0x696B, 0x9E56, 0xEEA1, 0xEF05, 0x00E7, 0x5892, 0x5C4F, 0x00D0,
+    0x726A, 0xEC46, 0x3633, 0x9164, 0xBCE7, 0xAF8F, 0xCFB8, 0xCBE6, 0x8DF5, 0x4FD2, 0x908A, 0xAD35,
+    0x4B4E, 0x803C, 0xF91B, 0x291C, 0xFDB3, 0xF200, 0x8013, 0x9664, 0x9CAE, 0x6F49, 0xD603, 0x0048,
+    0xEF17, 0x49F2, 0x1400, 0x00FD, 0x60DF, 0x7C0B, 0x9DBB, 0x61FE, 0xD7A2, 0x036D, 0xC1E3, 0xEC92,
+    0x9991, 0x2419, 0x2DEE, 0x64FC, 0x0AAD, 0xDB22, 0xF14C, 0xBCED, 0xF7E9, 0x1580, 0x14BC, 0xF75D,
+    0x0000, 0xA830, 0x0100, 0xD828, 0x490E, 0xBE07, 0x0000, 0xA4CE, 0x03DA, 0x17F9, 0x5A11, 0xBB6E,
+    0x9531, 0xE6D0, 0x5CE7, 0x1073, 0x4592, 0x2447, 0xD1FC, 0x0FEA, 0x8148, 0x9DF5, 0x350F, 0xEC00,
+    0x38C7, 0x92E4, 0xBA02, 0x404A, 0xDF35, 0x2549, 0x9249, 0xDC91, 0x1392, 0x4FC7, 0x7705, 0xFA77,
+    0x0609, 0xE0AC, 0xEC63, 0x9D57, 0xBE3B, 0xF75D, 0x2880, 0x1396, 0xE479, 0x4A00, 0x80F4, 0x7E91,
+    0x248F, 0x00E5, 0xF768, 0xEDD7, 0x8133, 0xA03D, 0xE25E, 0x7BC8, 0x9C91, 0xBCB3, 0xCB47, 0x4B0E,
+    0xF43E, 0xCF82, 0xF4B7, 0x41AE, 0x4FEF, 0xD6F7, 0x6335, 0xE807, 0x20D7, 0xF812, 0x0080, 0x0A1C,
+    0xBEFF, 0xAAAA, 0xAA9A, 0x9999, 0xE1FF, 0x802C, 0x832C, 0x1391, 0x3C45, 0x9E39, 0xC93F, 0x7F33,
+    0x4892, 0xAAAA, 0xAAC1, 0x711C, 0xC771, 0xDC01, 0x0000, 0x34B4, 0xA842, 0x5524, 0x570C, 0xFAA1,
+    0x710F, 0x608A, 0x5941, 0x0725, 0xF479, 0x5428, 0x3D4A, 0xA1FA, 0xE8F4, 0x182E, 0xDA11, 0x2E94,
+    0xF083, 0x0A26, 0x47E8, 0xF3C3, 0xABE2, 0x775E, 0x2BA3, 0x7FB4, 0xC761, 0x1209, 0x5B0D, 0xE51C,
+    0x5399, 0xBCB5, 0x4A7A, 0xD2E4, 0x5874, 0xEAA8, 0xE60C, 0x491A, 0x5E20, 0x9937, 0x0624, 0xCF99,
+    0x28CD, 0x1C81, 0x9296, 0x8C95, 0x80A9, 0xD152, 0xF255, 0x67D1, 0xC3A6, 0x86A2, 0x0A69, 0x7A80,
+    0x01E0, 0xC369, 0xBED9, 0xD9A0, 0x3C3D, 0x6321, 0xA462, 0xA0DB, 0x266A, 0xE37A, 0xD05B, 0xD554,
+    0x0604, 0x6E07, 0x6059, 0xA1D6, 0x98E0, 0x0568, 0x4560, 0xB13E, 0x0800, 0x2609, 0x9070, 0xC6EA,
+    0x723C, 0x8624, 0x8424, 0x8424, 0x8458, 0x1546, 0x750D, 0xC21D, 0x2021, 0x63AF, 0xFA42, 0x3236,
+    0xD54F, 0x73FA, 0x1965, 0x558F, 0x54DB, 0x76F7, 0xE8D2, 0x003B, 0x4002, 0x642C, 0xD778, 0xF274,
+    0x8D84, 0x24B4, 0xEA29, 0xC858, 0xAEF1, 0xE469, 0x6B85, 0x2400, 0xAB6A, 0x5480, 0xD845, 0xE519,
+    0xA509, 0x4908, 0x99A3, 0xED76, 0x5A01, 0x323E, 0x3FFF, 0x2440, 0x1200, 0xC812, 0x880B, 0xF881,
+    0x5535, 0xACB2, 0x8019, 0x2001, 0x32BA, 0x1C3D, 0x8095, 0xAAAB, 0xF9E0, 0xEDAA, 0x4302, 0x77DB,
+    0x0521, 0x0921, 0x0158, 0xF338, 0xCBC9, 0x1900, 0xCF58, 0x5596, 0xD5CC, 0x0620, 0x0990, 0x0448,
+    0x00E0, 0x1FF3, 0xB2E1, 0x02FE, 0x1907, 0x1020, 0x0192, 0x2500, 0xF4D0, 0x6A9A, 0xD94F, 0x1509,
+    0xD00D, 0x2109, 0x2161, 0xCDE9, 0xEE33, 0x6015, 0x64BC, 0x73BA, 0xFB0C, 0x5805, 0x2401, 0x9200,
+    0x2E20, 0xB380, 0xAC79, 0x9C65, 0x9DAE, 0xB266, 0x8004, 0x4802, 0x003F, 0xF003, 0x9FAD, 0x1328,
+    0x0221, 0x09A1, 0x46F6, 0x5D3F, 0xF4D6, 0xD16B, 0x01C9, 0xFDBB, 0xD5FD, 0xF7DF, 0x7FAF, 0xA1FE,
+    0xFEDD, 0xDEBB, 0x7F57, 0x7755, 0xDFBF, 0x7F3F, 0xD4F7, 0x7E68, 0x3FDC, 0xF77E, 0xFFBD, 0x1F7A,
+    0x7BFF, 0xBDD6, 0xFBE0, 0x0F1F, 0xFE7D, 0xF7DE, 0xF32B, 0xD4C3, 0x870F, 0xAE53, 0xB55D, 0xE1C3,
+    0x3EFC, 0xF0E1, 0xEADB, 0x71D5, 0xB7E1, 0xC387, 0x0FBF, 0x1ED4, 0xEBA1, 0x0E1F, 0x3EFC, 0xFCCA,
+    0x5AE1, 0xC30F, 0x3F7C, 0x491D, 0x5C49, 0x1DFC, 0x5D61, 0x0200, 0xB051, 0x92CC, 0xF56A, 0x712C,
+    0xC97D, 0xEAD9, 0x3D94, 0x2419, 0xEB3D, 0x616D, 0x447C, 0x5675, 0xC81D, 0x6B77, 0xAC99, 0x8B82,
+    0xDEEC, 0xE7D5, 0x28E3, 0x3F46, 0x6D30, 0xCE1C, 0x2F4E, 0xCEB1, 0x24B9, 0x9E00, 0x10FB, 0x4492,
+    0x24C7, 0x5592, 0xB725, 0xC97C, 0xEF46, 0xFC86, 0xC8C7, 0x89D8, 0xA7BF, 0x7AAF, 0x5521, 0x49F2,
+    0x2400, 0x407A, 0xFF48, 0x923A, 0xF3BF, 0x8AA6, 0x0AA4, 0xBF0B, 0x8EFB, 0xDE3D, 0x22C9, 0x2CAF,
+    0x8C36, 0x4EAC, 0x7E13, 0x06F0, 0x9411, 0xB1CA, 0x0D00, 0x0040, 0x8509, 0x00C0, 0x4649, 0x92EB,
+    0xA2AF, 0x3EBE, 0x1F39, 0x9BEF, 0x41CE, 0xE67B, 0x90B3, 0xD1E7, 0xAF89, 0x2B54, 0x0097, 0x2D24,
+    0x9F89, 0xCFAA, 0x4611, 0xE6B7, 0x6124, 0xBD45, 0x9224, 0xD752, 0xFF3D, 0xFA94, 0x7308, 0xE4CD,
+    0x7272, 0xB795, 0x4F8B, 0x6900, 0x38C7, 0x92E4, 0x7A02, 0x404A, 0xDF48, 0x9264, 0x75E5, 0x3D27,
+    0x7B52, 0x8306, 0x0D1A, 0x3468, 0x10EB, 0x6FD2, 0x31B4, 0xF7B1, 0xC985, 0x395F, 0xA124, 0x473B,
+    0xA312, 0xB256, 0xA124, 0x4FEA, 0x0100, 0xA4F7, 0x8F24, 0x493E, 0x1FC9, 0x054D, 0x630D, 0xB5F7,
+    0x3320, 0x57FB, 0xC6AD, 0x368D, 0x648D, 0x753F, 0x3B0B, 0xA838, 0x0168, 0x5F95, 0x61B7, 0x74BE,
+    0x2D54, 0x748F, 0x739F, 0x7002, 0xB4AB, 0x8EB7, 0xE4D6, 0x0FA0, 0xA577, 0xBFF9, 0x03D8, 0xF342,
+    0xAFEB, 0x9C00, 0x006C, 0x9424, 0xBF83, 0x9CCD, 0x4EAC, 0x546D, 0x3E09, 0x2B1B, 0x64E8, 0xF824,
+    0x6F1E, 0xE543, 0x8F5F, 0xADB0, 0xE676, 0xAF54, 0x2449, 0xBE6D, 0x66CC, 0x71F6, 0xE93D, 0x18C8,
+    0xCFAF, 0xAB00, 0x9C63, 0x4972, 0x3D01, 0x20A5, 0x4651, 0xE74E, 0x2F2D, 0x2F92, 0x2459, 0xBD1B,
+    0x00C0, 0x5C01, 0x207B, 0xA958, 0x2B9F, 0x5D7B, 0x56E5, 0x58CA, 0x88B8, 0x56D6, 0xF773, 0x60D7,
+    0xE35E, 0xBB4B, 0x324E, 0x6D8F, 0xE765, 0x1700, 0x00E9, 0xFD23, 0x4932, 0xC749, 0xF22D, 0x681F,
+    0x2F72, 0xED37, 0xC0FC, 0x7DE5, 0x1E99, 0xD4C5, 0xB774, 0x2FE3, 0x653C, 0x7F56, 0x9CFD, 0xEF74,
+    0xB8DE, 0x7183, 0xC723, 0x48C3, 0x8EF3, 0x6B1C, 0x91B9, 0xF595, 0x6A15, 0x6B68, 0xF1AF, 0xFA26,
+    0xA97C, 0x265F, 0x1FA9, 0xF1E3, 0x7DEE, 0x03D9, 0xA7F9, 0xAE19, 0x63BF, 0x1949, 0x92A4, 0xA764,
+    0x3DD5, 0xDECB, 0x6175, 0x8D77, 0x3081, 0x43D8, 0x7C8C, 0xD8A2, 0x672C, 0x8936, 0x8245, 0xA1F9,
+    0x80DF, 0xCAF0, 0x3109, 0x924B, 0x009D, 0xC6A4, 0x516D, 0x711A, 0xEE2A, 0x9546, 0xA476, 0xA566,
+    0x9CBD, 0x4E20, 0x8C9C, 0xDC8A, 0x77F2, 0xB3DC, 0x6B02, 0x2AE0, 0xC33F, 0xFFFA, 0xABAA, 0xC287,
+    0x0FBF, 0xFEFE, 0x9FDA, 0xC387, 0x1F56, 0x6155, 0xF827, 0x1220, 0x0990, 0xD5CF, 0x703C, 0xC3F1,
+    0x18D7, 0x1E10, 0xC771, 0x1E68, 0xE0F7, 0xAA0E, 0xCC00, 0x0990, 0x0400, 0xB2FF, 0xBBF6, 0xBAEA,
+    0xC0BF, 0x6E66, 0x4148, 0x4280, 0x1F4E, 0xCDEE, 0x5D3D, 0x8B69, 0xAC17, 0xD8B6, 0x40C6, 0x1470,
+    0x5CC3, 0x0049, 0x0063, 0x8FC7, 0xC178, 0x8AB8, 0x96A4, 0x6703, 0x15CF, 0xAC12, 0x0224, 0x40EC,
+    0x6E01, 0x2009, 0x9016, 0xDE5E, 0x85EC, 0x959E, 0xA939, 0x8710, 0x9210, 0xE073, 0xD2CE, 0x6B5D,
+    0xEA19, 0xAB1C, 0xBD66, 0x8F1A, 0x9EEA, 0x3981, 0x05F4, 0xA95E, 0xDD35, 0xD4A9, 0x5D3D, 0x7E9D,
+    0xCE39, 0x4F35, 0xA57E, 0x7C49, 0x803C, 0xB644, 0x47AF, 0x1248, 0x8004, 0x4820, 0x6377, 0x27E3,
+    0x9DA9, 0x35FF, 0x025E, 0x9F5E, 0x8EB6, 0x8B00, 0xC91A, 0xC0D1, 0x54D9, 0x4EBB, 0xC8F6, 0xF373,
+    0xEF91, 0x055C, 0xC05B, 0x7F1F, 0xA7ED, 0x31AE, 0x68B7, 0xDDAA, 0xCBA1, 0xA5F6, 0xD22E, 0x9735,
+    0x5C0E, 0xBBDB, 0x33EB, 0xDC45, 0x0D05, 0x9656, 0x95C5, 0x9866, 0xCCE1, 0xB4DA, 0x2E6D, 0xBBA6,
+    0x7589, 0xF025, 0xF0E1, 0xDFAA, 0xBA76, 0xA80E, 0x0FEA, 0xF0E1, 0xC387, 0xFFAA, 0x76E1, 0x87BF,
+    0x9EAE, 0xA8AE, 0xF7BE, 0xF7BD, 0xC287, 0x2F6F, 0x7DDB, 0xA387, 0xEAF0, 0xE1C3, 0x3E7C, 0xF8DC,
+    0x65AD, 0xD01E, 0xFE7A, 0x6675, 0xAE5E, 0x053D, 0xBF72, 0x5577, 0xEE3B, 0xE83D, 0x8509, 0x00B8,
+    0x3C03, 0x364A, 0x9E0E, 0xE938, 0x1BCE, 0x86B3, 0xE16C, 0xB824, 0xF786, 0x4B72, 0x6FB8, 0x24F7,
+    0x864B, 0x3289, 0x7BC7, 0xD7CE, 0x1A03, 0x9769, 0xCCF7, 0x06BA, 0x4EC0, 0x8723, 0x42D9, 0x7FF5,
+    0xEE27, 0x9EE3, 0xBDF2, 0x0380, 0x73EC, 0x3E76, 0xAF7C, 0x7036, 0x9C6D, 0x4972, 0x6FF8, 0xBDFE,
+    0x0020, 0xE7CE, 0xF259, 0x8ED7, 0xCC77, 0x78E1, 0x263B, 0x9C0D, 0x675B, 0xB23A, 0xAC0E, 0xABF3,
+    0xE1DE, 0xBAA0, 0x0100, 0x00A0, 0x2BF7, 0x2C5A, 0xA5FD, 0xBD35, 0xE233, 0xAA41, 0xD69A, 0xF419,
+    0x2598, 0xFDAF, 0x3FF4, 0x72EA, 0xC7D2, 0xE4E5, 0x5A2F, 0x3462, 0xAFD6, 0xDB53, 0xBA3F, 0x28A3,
+    0xD7C8, 0x2DDD, 0x2061, 0xB4E5, 0x8BA3, 0x4985, 0x4C8C, 0x1527, 0x56CC, 0x4C12, 0xA747, 0x4657,
+    0x46D4, 0x7F91, 0x2FB6, 0x8974, 0x64F4, 0x8B59, 0x62EE, 0x3353, 0xE247, 0xC58F, 0x5627, 0x5ABD,
+    0x68F5, 0xA359, 0x6439, 0x7F05, 0x5FF4, 0xBAF9, 0x9A19, 0x1A3D, 0x77D5, 0x639C, 0xBE53, 0x1834,
+    0x57DE, 0x6925, 0x9947, 0x9AEB, 0xBCFA, 0x9CF7, 0x6F8E, 0x68C6, 0x6C31, 0x2246, 0x99CC, 0xB4CD,
+    0xFC18, 0x6DEE, 0x3CE7, 0x1AB1, 0x383D, 0x05FD, 0x39A8, 0xF971, 0x39CF, 0x2A83, 0x9ADE, 0xBC7B,
+    0x7E52, 0x5D9E, 0xBEBA, 0xB27A, 0xD77E, 0x3498, 0x5DB0, 0xE607, 0x4085, 0x0900, 0x0004, 0xD4AC,
+    0x5C80, 0x9A5B, 0x2BE6, 0xA9EB, 0x1900, 0x31B3, 0xBE7A, 0x9C68, 0x1570, 0xE739, 0x8306, 0x10A6,
+    0x7E8E, 0x6656, 0x4DDD, 0xA0AE, 0xF279, 0xBC1E, 0x6A4E, 0x7A9B, 0xC9FC, 0x0135, 0xA756, 0xCDDC,
+    0xF9FA, 0x9616, 0x81E7, 0x1373, 0xB616, 0xFA07, 0x3AEA, 0x0B0D, 0xD5B8, 0x31EA, 0xACED, 0xADB6,
+    0xA0BF, 0xF503, 0x39F5, 0x5503, 0xBF40, 0xF582, 0x5CEA, 0xFCDE, 0x9979, 0x8EDC, 0x6BA5, 0xA3F7,
+    0x87DC, 0xCDD0, 0x8E5A, 0xF128, 0xB031, 0x4E73, 0xB77D, 0x09F9, 0xBB11, 0x3155, 0x94A3, 0x9E4E,
+    0xFBD2, 0xFC4E, 0x6C8B, 0x89B3, 0xCE66, 0x3BFD, 0x43C2, 0xE0A7, 0x6AEA, 0xEF6C, 0xA3D2, 0xA81F,
+    0x0CCF, 0xF489, 0xBA57, 0x0BD3, 0x5D3F, 0xB29E, 0xC807, 0x6D9E, 0xD618, 0xE9EB, 0xFF86, 0x0CC2,
+    0xFBB9, 0xC923, 0x8BEA, 0xFB38, 0xBCFC, 0x1C19, 0x94E4, 0xCE59, 0xE205, 0x3D54, 0xEAC4, 0xAFE3,
+    0xC82F, 0xAEA3, 0xA1A3, 0x9FAD, 0x9E8E, 0x128C, 0xBCAA, 0x455E, 0xB5B7, 0x1CCC, 0x73B5, 0x73E9,
+    0x2BC3, 0xE4F8, 0x7B85, 0xC361, 0x114C, 0xEAEA, 0x7598, 0xEED3, 0x95BC, 0x51FD, 0xB353, 0x195E,
+    0x46F6, 0xBBDE, 0x3C4B, 0x89CA, 0x30CE, 0x3A4F, 0x4F0F, 0x9915, 0xDF7D, 0x2B23, 0xACA5, 0xC88D,
+    0xF77C, 0xF2E9, 0x3852, 0x736E, 0x7DAC, 0x1CEB, 0x9C53, 0x4472, 0xC69D, 0x67F6, 0x59E5, 0x76EE,
+    0xD9CD, 0xC384, 0x9901, 0x6819, 0x0919, 0x1700, 0x0040, 0x057C, 0xFBD7, 0xF7EF, 0xDFBF, 0xDBAB,
+    0xAA1E, 0xBFFF, 0x3EF4, 0x78F5, 0xDFB7, 0xF0FF, 0x5DD5, 0x426B, 0xDB8E, 0xEBAA, 0x7FF0, 0x3AA9,
+    0x5E0C, 0x16B2, 0xB54E, 0x8241, 0x9926, 0x0026, 0x235A, 0x8422, 0x3FDD, 0xA6E6, 0xC111, 0x93E6,
+    0x3539, 0x3ED5, 0x5575, 0x0381, 0xE181, 0xEAF9, 0x4AEF, 0x181E, 0x8274, 0xACD4, 0xC0A6, 0x313B,
+    0xE2E6, 0xC167, 0x08C3, 0x6307, 0xC458, 0xC659, 0x241F, 0x0208, 0x30FA, 0x8FFA, 0xC7FD, 0xCEEC,
+    0x764E, 0x08AB, 0xF67D, 0x87AA, 0xEAED, 0x55C1, 0xF792, 0x00E1, 0xB289, 0x0BC8, 0x1254, 0x1F75,
+    0x826A, 0x562F, 0x48D7, 0x6857, 0x13D5, 0x580E, 0xA392, 0xA176, 0xB907, 0x9D67, 0xD470, 0x8490,
+    0x1AEA, 0x229D, 0xEEAE, 0xD1E9, 0xA471, 0xCD61, 0x18D5, 0x24C7, 0x59D3, 0xC558, 0xDDE5, 0x67A9,
+    0xC5D2, 0x7876, 0x5A39, 0x93AE, 0xD2D3, 0x39DA, 0x3B95, 0x211E, 0x794B, 0xE003, 0x9200, 0x812A,
+    0xAE35, 0x6AE8, 0x59BE, 0x6D5D, 0x593A, 0xBB99, 0x9D33, 0x787B, 0xD0E4, 0x2D32, 0xF61E, 0x671D,
+    0xB239, 0xCB71, 0xA61B, 0xD6D2, 0xD6AD, 0xD1BE, 0xD6A9, 0x4E5B, 0xF574, 0x1CD3, 0x51A3, 0x4727,
+    0x35AA, 0x8E0E, 0xA82A, 0xABAA, 0x6BD7, 0xAAFA, 0x8124, 0xE06D, 0xD96B, 0xAD4A, 0xF3EB, 0xAE65,
+    0xD5A5, 0xAF1B, 0xC6CE, 0x98AB, 0x884B, 0xABD4, 0xEA9E, 0xFC83, 0xE3D4, 0x6E9D, 0x5D95, 0x4126,
+    0xF7E0, 0x2773, 0xB7B5, 0x355E, 0x1FAC, 0x3362, 0x59D0, 0x40E2, 0xADDE, 0xD265, 0xF578, 0xF5D1,
+    0x75EC, 0xD975, 0xEDA4, 0x6ABA, 0x56A5, 0x6B40, 0x3F73, 0x9F72, 0xF32B, 0x718D, 0xB3EC, 0xAA3A,
+    0x400B, 0xEC29, 0xBA1C, 0x5475, 0xB531, 0xB5B5, 0xE6E8, 0xD1AE, 0x7614, 0x670F, 0xDAE9, 0xA8B9,
+    0xCA51, 0x3AB4, 0x9CB3, 0x468D, 0xD5F7, 0x0080, 0x047E, 0xDDDD, 0x75BF, 0xBFD7, 0x6FFB, 0x7BDD,
+    0xBFDD, 0xBDAB, 0xDFF5, 0xF7FB, 0xEFDD, 0xF7D7, 0x55FD, 0xF77E, 0xA18A, 0xE882, 0x20DE, 0x7183,
+    0x0B0A, 0x73AC, 0x6BDF, 0x7626, 0x77A4, 0xB021, 0x2422, 0x2DA6, 0x5120, 0x28A8, 0xA338, 0x51F9,
+    0xAC30, 0xC71C, 0x2CD1, 0x7966, 0x1270, 0x8A36, 0x74C8, 0x36AD, 0x5C4D, 0xB71D, 0x8030, 0xE3A3,
+    0xFE3F, 0x6F66, 0xF31C, 0x6030, 0x8386, 0x46CA, 0xF861, 0x3324, 0x0570, 0x547F, 0xE683, 0x1ED7,
+    0x9D61, 0x0C01, 0x34CE, 0x1658, 0x014C, 0xEBB1, 0x781C, 0xCDB7, 0x6627, 0x5234, 0xBC2F, 0x0342,
+    0x6880, 0x3F0E, 0x2000, 0x7209, 0x5FDD, 0xAD4E, 0x5A79, 0xF878, 0xC204, 0x0040, 0x7483, 0x0AE4,
+    0xE4BE, 0x8CB9, 0x0CF2, 0xE955, 0xE76D, 0xFACE, 0x9BEF, 0x1E1E, 0x475F, 0x2765, 0x4D47, 0xDF84,
+    0x307E, 0xA455, 0x2848, 0xFADA, 0xDDED, 0xEE76, 0x0652, 0x6804, 0x8DC6, 0x2411, 0x6934, 0x64D1,
+    0x6834, 0xDF6B, 0x1698, 0x38E8, 0x68D0, 0x071B, 0x0B13, 0x1585, 0x9B2F, 0x9E76, 0x3DD7, 0x85BA,
+    0xBA86, 0x1AF7, 0xD85B, 0x5D89, 0x281A, 0x924D, 0xC3B6, 0x2FDA, 0x1ACE, 0xD55C, 0xDDB4, 0xC0BD,
+    0xEA96, 0x6557, 0x9A8A, 0x35AD, 0xD5F3, 0x5B8D, 0x2664, 0x5FBF, 0xE67B, 0x68EF, 0x16D2, 0xD77C,
+    0x4FF5, 0x94AA, 0x764A, 0xEABE, 0xEE19, 0xA6A7, 0x49F9, 0x1BA9, 0x77CE, 0x7894, 0xF7D6, 0x9A21,
+    0xCDB9, 0xB465, 0x6EF4, 0xBCBB, 0x2CA3, 0xBDE9, 0x81D4, 0xBBD7, 0x8BF6, 0x202A, 0xFAF6, 0xAC06,
+    0x0000, 0x1526, 0xF0DD, 0xAFA3, 0xB966, 0x79CF, 0xE703, 0xCCDE, 0xC19D, 0x2C06, 0x99EB, 0x9F51,
+    0x8EFF, 0x5A94, 0x4F87, 0xDC71, 0xD8AD, 0xC5E3, 0xB719, 0x8CEA, 0xDBD1, 0x62CC, 0xF62C, 0x7A06,
+    0xEF42, 0xE958, 0xF88C, 0x5057, 0x1277, 0x413A, 0x3A28, 0x396A, 0xB796, 0x1FCB, 0x6FED, 0xFE5C,
+    0xBDDA, 0xB6CC, 0x53CD, 0xB887, 0x75EF, 0x27D1, 0xBC4F, 0x0B71, 0xBC5C, 0x3051, 0x5C73, 0x69F6,
+    0x298E, 0xE159, 0x9EF7, 0x289C, 0x6CF9, 0x729A, 0xB2B3, 0x29A5, 0x9452, 0x4AA1, 0x1B4C, 0xF774,
+    0x83BA, 0x0C21, 0x856E, 0xCA8D, 0xF702, 0x3D99, 0x79FA, 0x523F, 0x7519, 0xED6D, 0x27BE, 0x7F3F,
+    0x2527, 0x9D60, 0xFC86, 0xAB60, 0xDE77, 0xF500, 0x0000, 0x2A4C, 0x9830, 0x6102, 0x1948, 0x7FC0,
+    0xDA6F, 0xC278, 0x778C, 0xAEE6, 0xD1CB, 0x3377, 0xCEE8, 0xDDD6, 0x6DC2, 0x5452, 0x9EAA, 0xF79A,
+    0x0329, 0x78F7, 0x5B67, 0xD154, 0x55A8, 0x2AB4, 0xA2C7, 0x5797, 0xB1EA, 0xA37A, 0xE4D7, 0xB232,
+    0x7AF2, 0xB2F4, 0xAEEE, 0x703E, 0x5495, 0x3A91, 0x959E, 0x6CBB, 0x7C8A, 0x86AC, 0x1954, 0xAC7D,
+    0x66D6, 0x6C5E, 0xB134, 0xD7EE, 0xE37C, 0x424B, 0x5B29, 0xCB31, 0x4F59, 0x2D8C, 0xA191, 0x4571,
+    0x1E5B, 0x9284, 0x655B, 0x702C, 0x58CE, 0xF3B8, 0xA4A3, 0x99A6, 0x69B2, 0xDF77, 0xA5DC, 0xA52D,
+    0xA594, 0xCD55, 0x8242, 0xD699, 0xA273, 0x354B, 0xB59A, 0xB2A5, 0xDB54, 0x5B1B, 0x3911, 0x5AAE,
+    0xA088, 0xCC63, 0x18F5, 0x3023, 0xAA54, 0x9946, 0x254C, 0xF17D, 0xC5A7, 0x4EDD, 0xD3C3, 0xF430,
+    0xD3D3, 0x3D3D, 0x8CB9, 0xE25A, 0xB5B0, 0xB71B, 0xC6FB, 0xC4DB, 0x770C, 0xA34E, 0x9D95, 0x2773,
+    0x5360, 0x0000, 0x0015, 0xF0FF, 0xB2EA, 0x35F6, 0x7FDD, 0xF80F, 0x0A7F, 0x56A7, 0x4F9C, 0x1BD2,
+    0x4690, 0xA64C, 0xCDC1, 0xDA6A, 0xD071, 0x8CFB, 0x58CC, 0xFA5E, 0x737F, 0xFA23, 0x6130, 0xA673,
+    0x00FE, 0xFA66, 0x3409, 0x6D65, 0xA48B, 0x8C47, 0x7CDF, 0x69CD, 0x7E27, 0x0CF2, 0x9032, 0x6081,
+    0xB356, 0x483F, 0x6751, 0xD767, 0xBED0, 0x6BE6, 0x2099, 0xD6B3, 0x5400, 0x8A09, 0x1181, 0x1F67,
+    0x633E, 0x4786, 0xACEA, 0x1227, 0xA92E, 0x6E0F, 0x4198, 0xC033, 0xCE72, 0x9F26, 0xAF86, 0x1B37,
+    0x304F, 0x0AF3, 0x2950, 0x1550, 0x57A7, 0xFCD4, 0xC91B, 0xB928, 0xDC21, 0x5118, 0x58AE, 0xD0F2,
+    0xF4E7, 0xF263, 0x180D, 0xAAA9, 0x8714, 0xD29A, 0xE248, 0x018E, 0xF620, 0x8EC5, 0x756F, 0x7B6F,
+    0xF688, 0x2100, 0xC4E1, 0x0D67, 0x7100, 0xDAFD, 0x2D8E, 0x0A67, 0xEC92, 0x4A41, 0xF9D9, 0x89C2,
+    0x34D0, 0x0481, 0xE106, 0x5719, 0x939F, 0x1BB3, 0x2CB7, 0xCD20, 0xB00F, 0xDFDE, 0xAD08, 0x3500,
+    0x7CD8, 0x46DF, 0x1848, 0x7772, 0x5039, 0x3C1C, 0x0914, 0x628A, 0x30A5, 0x605C, 0x3BD3, 0x6EAD,
+    0x7F7A, 0x7996, 0x6E66, 0xB8ED, 0x5F6E, 0xAB6F, 0xDFA1, 0x5D85, 0x0F57, 0xAFFA, 0xACDA, 0xDB7E,
+    0xFF7F, 0x8300, 0xE036, 0x1361, 0x4CA0, 0x3CBA, 0xE5E0, 0x87EF, 0x7DFA, 0x4EEE, 0x273D, 0x29BC,
+    0x09C1, 0xA707, 0x1628, 0x5B11, 0xF92F, 0x4BDB, 0x0322, 0xAF1E, 0x305C, 0x0102, 0xFBED, 0x24D8,
+    0xB94C, 0x38AE, 0xF739, 0xECC6, 0xAB3B, 0xC1CF, 0xA6D2, 0x4AE6, 0xF77A, 0x074C, 0xC5A9, 0xA6B9,
+    0x8168, 0x770D, 0xBF01, 0xD34E, 0x3620, 0xABAE, 0x80EE, 0x7AC4, 0xC126, 0xA076, 0x7E17, 0xD383,
+    0xA870, 0x9475, 0x4111, 0xE555, 0xC66B, 0xAD6B, 0x420E, 0xFA61, 0xCC80, 0x1638, 0xA641, 0x9BE5,
+    0x2F97, 0x2DC5, 0xE6EE, 0xCE4B, 0x1DBF, 0x5E79, 0xEE67, 0xE060, 0x94D0, 0xD304, 0x8CE7, 0x7202,
+    0x8223, 0xDC31, 0x30B3, 0x9B62, 0xF68D, 0x38DD, 0xCD40, 0xA10E, 0x8925, 0xCD7D, 0x3B0E, 0x7D72,
+    0x8E79, 0x9E7E, 0x4D2F, 0x8C18, 0x2C20, 0x0754, 0x3B54, 0xE299, 0xB00F, 0xE0D1, 0xE3D6, 0x2571,
+    0x8103, 0xC145, 0x1256, 0xBCBF, 0x4343, 0xFE9F, 0xEF32, 0x5C11, 0x9F3A, 0xCF9F, 0x21F5, 0x29FF,
+    0xC707, 0x2B67, 0x4058, 0x0338, 0x342B, 0x76EE, 0x0C1C, 0x102E, 0x4F57, 0x127D, 0xDEA9, 0xCB42,
+    0x4552, 0xE28B, 0xCDE7, 0x0A5C, 0xEF17, 0x9DCA, 0xC9DD, 0xDE65, 0xCF6D, 0x4F9F, 0xD6E1, 0xF37F,
+    0x237B, 0x65B0, 0x07DC, 0x6582, 0xE70A, 0x287F, 0x9C2B, 0x7906, 0xA90F, 0xFF49, 0x7023, 0x84B6,
+    0x808B, 0x5206, 0x0F06, 0x3CE1, 0x4279, 0x21BC, 0xF975, 0x34E0, 0xC72E, 0xC991, 0x797E, 0x8CE7,
+    0x19A0, 0xE32F, 0x24C0, 0xDC86, 0x8368, 0x403A, 0x70E2, 0x7A00, 0xC052, 0xD50E, 0x3DA6, 0x8012,
+    0xF585, 0x117D, 0xF2BE, 0x5F39, 0xE8A6, 0xFA34, 0x01CA, 0x6792, 0x35E1, 0xA0E1, 0x1E4B, 0x4FF6,
+    0xBC49, 0xADCD, 0x747A, 0xF5E2, 0x2095, 0xF2D6, 0x8461, 0xF85A, 0x8CCA, 0x0663, 0x9EF0, 0x6953,
+    0x517E, 0x1F15, 0x7823, 0xF212, 0x3314, 0x7A84, 0x7062, 0xFD37, 0x332A, 0x6496, 0x27B9, 0xFF7F,
+    0xADB6, 0x9E20, 0x4400, 0xC8C7, 0x0144, 0x4221, 0x244E, 0xCEA1, 0xD944, 0xE325, 0x4C91, 0x6FED,
+    0xD459, 0xF0DB, 0x9FE5, 0x1E71, 0xBF15, 0xB577, 0x7DBB, 0xFFFC, 0xF811, 0x6526, 0xBCD2, 0xFDEF,
+    0xBEBE, 0x7B8F, 0x6D57, 0x55D0, 0xE157, 0x0A13, 0x0000, 0xA040, 0x5983, 0xE8BE, 0x1A4F, 0x3C0B,
+    0xBA66, 0x27B9, 0x954E, 0x50FD, 0x5C92, 0x9E1C, 0x1C7E, 0xA513, 0x542F, 0x33FF, 0x5AF7, 0xA765,
+    0xBBC9, 0x4A35, 0xA8CF, 0x8A56, 0x59DF, 0x04DE, 0x3FE0, 0x8FE4, 0xF789, 0xAECD, 0xBA5A, 0xB5A0,
+    0x06C9, 0xAF1D, 0x57CF, 0x0D9F, 0xEF8E, 0x44E7, 0x7347, 0xA0A2, 0xF069, 0xA9F1, 0xABA6, 0xA8EC,
+    0xEBE2, 0xEB9A, 0x43DF, 0x032B, 0xD355, 0x1F29, 0x6762, 0xE1E3, 0x0274, 0xE88B, 0x44E1, 0x5267,
+    0x4A1A, 0x2F4F, 0xE255, 0xEB21, 0xF72E, 0x7911, 0x6ED8, 0x6E60, 0x3F0E, 0x9FCD, 0xE7F2, 0x9FE2,
+    0xC1E4, 0x5237, 0xD9C0, 0xE6B0, 0x5940, 0x028B, 0xCD02, 0x163B, 0x691A, 0xA6C1, 0xFEDA, 0x03FB,
+    0x8C96, 0xBDFA, 0xD9D6, 0x8E8C, 0xA3D9, 0x9FED, 0x7B96, 0xEF88, 0xF15C, 0x3497, 0x3C79, 0xC7AD,
+    0xAF7F, 0xEC28, 0x3162, 0xAB8A, 0x9E52, 0x34F7, 0xEECA, 0xAFCA, 0x9673, 0x7911, 0xDB58, 0x1F80,
+    0x01D1, 0x1138, 0x2E18, 0x483C, 0x1C24, 0x2AF4, 0x46A2, 0x436E, 0x7724, 0x8E0B, 0x1A12, 0x679B,
+    0x2D4C, 0xB5BF, 0x4DE9, 0x6EA9, 0xBE63, 0x5B42, 0x13B6, 0x670B, 0x4338, 0xD216, 0x99EA, 0x3BD7,
+    0x4B8D, 0x6667, 0x30FA, 0xB5F7, 0x7C05, 0x6AE7, 0x9BE7, 0x548D, 0x9AAF, 0x8729, 0x7E54, 0xC6E4,
+    0x316B, 0x90DD, 0xAFEE, 0xB044, 0x8DCF, 0xDCF3, 0x75E4, 0xCF0B, 0x976F, 0xD4B9, 0x5607, 0x0000,
+    0x0015, 0x2600, 0x0000, 0x203A, 0xD6BD, 0x5CEE, 0x75F3, 0x3D15, 0x097E, 0xF72B, 0xC84C, 0xCF71,
+    0x6AB9, 0x4A15, 0x0AC5, 0x4A45, 0x4A3B, 0x3731, 0x8EE3, 0x7A27, 0xD2FC, 0xE338, 0xDCBC, 0xD0B8,
+    0xD5E2, 0x60E2, 0x7970, 0xB0A9, 0xF401, 0x4E4F, 0x8B7D, 0x7A1D, 0xD4A8, 0x3D1B, 0xDE60, 0x9034,
+    0x02F3, 0x5799, 0xF966, 0xB367, 0x25B3, 0xD907, 0xA7F1, 0x188F, 0xD1C7, 0x6F74, 0x3AD2, 0x701B,
+    0xD7AD, 0x0E7A, 0xE25B, 0x335A, 0x3BF7, 0xDE95, 0x0151, 0xF63B, 0xC717, 0x0000, 0x0050, 0x6102,
+    0x00A0, 0xC358, 0x7B41, 0xDF77, 0x1B15, 0x978C, 0x15DF, 0x587C, 0x4E76, 0x10E8, 0x824B, 0xDEE7,
+    0x2C91, 0x9BFA, 0x4E96, 0xFD28, 0xD591, 0x16B5, 0x1869, 0xE45D, 0xA4BA, 0x893C, 0x4444, 0x77F4,
+    0x7C3D, 0xD424, 0x33B5, 0x22E6, 0x2B69, 0x5866, 0xAB86, 0xA961, 0x6A98, 0xA878, 0x3BD7, 0xBC67,
+    0xDB07, 0x8901, 0x7050, 0xD8EA, 0x6F59, 0x6BA6, 0x4657, 0xE8EC, 0xDC11, 0x9EED, 0xFAA7, 0xF34B,
+    0xCF97, 0xA2BB, 0xB9DB, 0x13FC, 0x7D3C, 0x75FD, 0xB485, 0x23A5, 0x9452, 0x186A, 0xD4A2, 0xC9F3,
+    0x26F7, 0xCB7B, 0xDA0C, 0x19E3, 0x5F6F, 0x0B6A, 0xDA3C, 0x2072, 0xD753, 0x60AD, 0xC755, 0x6E07,
+    0x2296, 0x63FF, 0x0000, 0xA820, 0x9000, 0x01FA, 0x2947, 0x7B75, 0xF951, 0x7327, 0xDD35, 0x1C3A,
+    0xE65C, 0xF6AC, 0xAEA5, 0x53F7, 0xA04F, 0x6A68, 0x15AF, 0x5553, 0x772B, 0xAC6B, 0xAD24, 0xA7E6,
+    0x4E5A, 0xED51, 0x6D14, 0xE887, 0x3354, 0x9635, 0xB767, 0x8D63, 0xADAA, 0x6A95, 0x76D7, 0x965D,
+    0xEF99, 0x7ADA, 0x3D56, 0x3B6A, 0xB456, 0xB9B5, 0x1DBD, 0x7A56, 0xAB73, 0x5896, 0xF312, 0x1BB8,
+    0x8024, 0x4080, 0xA73C, 0x6577, 0xFA1A, 0x006F, 0x0135, 0xCBAA, 0xB261, 0x96E6, 0x38CB, 0x5E7B,
+    0xEBF8, 0xF48C, 0x1EDD, 0x4EED, 0xB6A3, 0x021F, 0x9004, 0xC819, 0x5759, 0xCD9E, 0xCDF5, 0xB422,
+    0x63B7, 0xD543, 0x6795, 0x4E9B, 0x6FB8, 0x5C56, 0x97D6, 0xB0AA, 0xCBD2, 0xF63A, 0x2A3D, 0xAACA,
+    0xAE41, 0xA0CA, 0x9EF5, 0xCCBD, 0xBA87, 0x72C6, 0x1448, 0x0264, 0x0EA8, 0x71DA, 0x51E5, 0x547D,
+    0xD4A1, 0x3AAD, 0xC773, 0xAAE7, 0x3AE3, 0x4C67, 0x8D55, 0x6B16, 0x90EE, 0xE619, 0x0E31, 0x1D7A,
+    0x00A7, 0xAC9A, 0x934B, 0x2DCB, 0xF68C, 0x3DEC, 0xEA7F, 0xA581, 0x043E, 0xBFD3, 0x6A84, 0xDCB4,
+    0x39C0, 0xCE03, 0x2220, 0x06C0, 0x751C, 0x0501, 0x3893, 0x0457, 0xCF1B, 0xD4C3, 0x88FB, 0x6BBD,
+    0xFFEB, 0xBDFB, 0x7EFB, 0xFA9F, 0x6F3F, 0xE100, 0xE260, 0xCF5F, 0xA813, 0x8251, 0x0614, 0x081B,
+    0x1C60, 0x5F06, 0x08FC, 0xF811, 0x65A6, 0xB677, 0xEFDA, 0x77C5, 0xB41F, 0xDDAF, 0x920F, 0x00BE,
+    0x2BB8, 0x571D, 0x4151, 0x5E59, 0x02BA, 0xBE4E, 0x663A, 0x22D5, 0x0E8F, 0x3819, 0x5F77, 0x61C8,
+    0x8009, 0xC282, 0xCD18, 0x1743, 0xD9D1, 0x74F6, 0xBCA8, 0xCD3C, 0xD705, 0xFCEF, 0xADBF, 0xAADB,
+    0x55AD, 0x1E3E, 0x7CFC, 0xAA55, 0xC188, 0xEF39, 0x8860, 0x001B, 0x1CA0, 0x5FCE, 0x1982, 0xF008,
+    0x0700, 0x9897, 0xA10E, 0xD4BB, 0xB7B8, 0x2BC2, 0x5BC0, 0x0129, 0x93F5, 0x260E, 0xBEDF, 0xE001,
+    0xD1BB, 0xEF9C, 0xFEF2, 0xA6D8, 0x6631, 0x22EE, 0x18C5, 0x0205, 0x5607, 0xC612, 0x84A8, 0xD43D,
+    0xA3E4, 0xE11A, 0x30C8, 0xB580, 0x8B8E, 0x32DB, 0x2862, 0x33ED, 0x1B0A, 0x18A3, 0x8EBE, 0x5DEA,
+    0x3DAB, 0x2822, 0xB917, 0x35B2, 0x3A0F, 0xC3E3, 0xA278, 0xDDD3, 0xEBDF, 0xE5B2, 0x151E, 0x2CC9,
+    0xB57A, 0x680B, 0xB5EF, 0x0C7B, 0xFF9F, 0xFD7D, 0x831C, 0x96BE, 0x801E, 0x9844, 0xB51E, 0x29C1,
+    0x01D3, 0x0E0D, 0xC73B, 0x42FD, 0xA21A, 0x7704, 0x06BF, 0x288F, 0x3EE6, 0x8021, 0x84C0, 0x4938,
+    0x03AF, 0x6C77, 0x0C37, 0x6377, 0xF3BC, 0x2D54, 0xBE19, 0x7B4E, 0x0C05, 0x3050, 0x0B92, 0xDEE6,
+    0x2B35, 0xA965, 0x3D7F, 0xA78E, 0x3E5D, 0x5F6A, 0xCEF2, 0x23D1, 0x5FA1, 0xAA6A, 0xE5E1, 0xC3D7,
+    0x6AC5, 0xFA75, 0xFD23, 0x2880, 0xFBA3, 0x0700, 0x6E59, 0x50C0, 0x1CCE, 0xF814, 0x421A, 0xC74D,
+    0xB0C7, 0xDBE6, 0x7DD9, 0x2685, 0x3B2D, 0xDCE7, 0xD2B8, 0x73A1, 0x9DBC, 0x61BF, 0x8F8B, 0x0C6A,
+    0x94BB, 0x3DF9, 0xDD8B, 0x8369, 0x2E4F, 0x1F8B, 0x3703, 0x81C9, 0x3319, 0x7A62, 0xDE48, 0x9D42,
+    0x23DA, 0xCFE1, 0x983F, 0xC200, 0x001C, 0xF492, 0x70D2, 0x4220, 0x323F, 0x5006, 0xA26F, 0xCD9A,
+    0xCB6B, 0x74FA, 0x6AC2, 0xFBDC, 0x7B88, 0x8355, 0x2872, 0x2424, 0x0E07, 0x1EE3, 0xAC61, 0x4220,
+    0xEEAE, 0x67D8, 0x91DD, 0x1DC2, 0x204B, 0xF3DC, 0x8078, 0x8C5B, 0x0002, 0x1CE7, 0x9DC4, 0xA6DB,
+    0x5C59, 0x4E0C, 0x4590, 0x924B, 0x9BDF, 0x66C4, 0xA09D, 0x8EAE, 0x60FF, 0x4DED, 0x409C, 0x40D8,
+    0x2F22, 0x423F, 0x1A1F, 0x1F49, 0x608D, 0x4441, 0x8CEC, 0x6237, 0xDA22, 0xF451, 0x0BF8, 0xF6F5,
+    0x3B87, 0x6150, 0x2A83, 0xCF2D, 0x6A8C, 0xE35C, 0xEB5F, 0xF75A, 0x4DF0, 0x6BFB, 0x8EB5, 0xC6D5,
+    0x51B5, 0xE0DB, 0x0813, 0x0000, 0x2800, 0x08F5, 0x7BA2, 0x7E97, 0x8C15, 0xDF13, 0xF5BB, 0x5462,
+    0xD832, 0x2532, 0x2532, 0x2556, 0x4AEC, 0x665A, 0x7E77, 0x854A, 0x67B0, 0xD83C, 0x7E2B, 0x3219,
+    0x143F, 0x9B41, 0x1D79, 0xEF44, 0xBE0F, 0xE53B, 0xEEEE, 0x79E7, 0xAE9D, 0xDE16, 0x868B, 0x7C4F,
+    0xA1D0, 0xD27D, 0x2D7A, 0x7C45, 0xCCBA, 0x7EBC, 0x9C2A, 0x7D8F, 0x7D1D, 0xEFFD, 0xB257, 0x66A9,
+    0xA311, 0x54BA, 0xE6CA, 0x95DC, 0xBD74, 0x5DDB, 0x12E6, 0x65AC, 0x8858, 0x1995, 0x31EF, 0xC937,
+    0xA6B1, 0x97D6, 0x5F35, 0x4D57, 0x1555, 0x65FF, 0xEA52, 0x4AD9, 0xBDD5, 0xC9A1, 0x3B59, 0xFC36,
+    0x61B2, 0x99D9, 0x0D29, 0x45B3, 0x21BB, 0x5729, 0x99F6, 0x0A81, 0xD9A6, 0x62AF, 0xA8CE, 0xBB97,
+    0xBAE2, 0xE97C, 0xC7F9, 0xEFCC, 0x82EC, 0xD4AC, 0x87C6, 0x4062, 0xDE79, 0x7402, 0x0050, 0x6102,
+    0x0000, 0xE829, 0xC05E, 0x5038, 0x21E7, 0x1BB5, 0x2420, 0x3F53, 0x97C5, 0xBB5A, 0x4C69, 0xEECE,
+    0xFF7C, 0x4D28, 0xA7BE, 0xA703, 0xDFC2, 0x2BF6, 0x69A6, 0xE663, 0xF338, 0x5CB8, 0xF3B5, 0xF7EC,
+    0x7DAE, 0xBAF8, 0xA95C, 0x5A6E, 0x92CD, 0x06C8, 0x14A6, 0xA95E, 0x730E, 0xFFD5, 0x34AD, 0xE771,
+    0xF2CB, 0x563B, 0x6BED, 0x88D8, 0x5A59, 0x849E, 0xB262, 0xA8F4, 0x59C6, 0xBD99, 0x7936, 0x2DAF,
+    0xA577, 0xFF64, 0x5617, 0x6C24, 0x6E18, 0x3D76, 0xFD37, 0x5563, 0xC78C, 0x5A07, 0x2387, 0xBB0B,
+    0x6ECC, 0x78AA, 0x4B17, 0x2D57, 0x2B4E, 0xBB3B, 0x5A7A, 0x1BBD, 0x566A, 0xEC16, 0x43E9, 0x15F1,
+    0xF6CD, 0xE9E9, 0xABA5, 0x466B, 0x0FF7, 0x3DA7, 0x61C8, 0x9CF1, 0x464D, 0xC9DD, 0x9188, 0xA11A,
+    0x2A45, 0x06DF, 0x5993, 0x816F, 0xABE9, 0x12C1, 0x748E, 0xF758, 0x4D02, 0x02BD, 0x6FC7, 0xA101,
+    0x0000, 0xA830, 0x0100, 0x009E, 0xFD23, 0xFC06, 0x7DEF, 0x7B30, 0x819F, 0x2D0D, 0x3BA7, 0x409D,
+    0xBAAF, 0xF36E, 0xEF4E, 0x494F, 0x66F5, 0x912D, 0xBBE4, 0x4636, 0x3D35, 0x35E6, 0x8293, 0xA387,
+    0xD0E2, 0x355C, 0x74A2, 0xA755, 0xF8DB, 0x098A, 0x6D47, 0x78FE, 0xF9D0, 0xB227, 0xD633, 0xB739,
+    0x6C92, 0x4125, 0x29CB, 0xCEC6, 0x062D, 0xB743, 0xDC14, 0xCFA9, 0xA0C1, 0x842C, 0x51DF, 0x1673,
+    0x865C, 0x2E5E, 0x31A2, 0xF9FC, 0xF505, 0x0000, 0x0000, 0x15F0, 0xB9AB, 0xAC56, 0x6FA7, 0xE619,
+    0xAC67, 0x0900, 0x4C9B, 0x684E, 0xA144, 0x1F08, 0x8B8D, 0x2758, 0xF60E, 0x30A6, 0xAACD, 0x5BC9,
+    0xDE09, 0x30CF, 0x702A, 0x1ED3, 0x6CA1, 0x0EA3, 0x0700, 0x3837, 0xCA97, 0x6B05, 0x860C, 0xD51E,
+    0x40F1, 0xF348, 0x310F, 0xC014, 0x9EE6, 0x969D, 0xD103, 0x9BCA, 0x866C, 0xF453, 0xE6B0, 0x78ED,
+    0xA264, 0x1E26, 0x081D, 0x751D, 0x4FE3, 0xD097, 0x47DE, 0xCC0D, 0xE891, 0x093C, 0x3654, 0x2C9E,
+    0x120A, 0x09E0, 0x39F1, 0x60F1, 0xCFC8, 0xAAC7, 0xE1BB, 0x0575, 0xE253, 0x8310, 0x00D0, 0x7F90,
+    0xC0B0, 0x36AE, 0x7188, 0x23DC, 0x657B, 0xBCB8, 0xA99C, 0x4183, 0xCDA6, 0x3C9A, 0xDCAB, 0xDFD6,
+    0xB166, 0xFD0F, 0x0A70, 0x7B75, 0x38C2, 0x1B7A, 0x55C3, 0x0E20, 0x3CA0, 0x025F, 0xEDF1, 0x3195,
+    0x8743, 0xCC3B, 0x5B6F, 0x4F7C, 0xF2B8, 0x3D71, 0xBCF7, 0xFD3D, 0x3832, 0xC7C2, 0x5415, 0xFC0B,
+    0x0910, 0x90C7, 0x9A25, 0x502E, 0xEDB6, 0x8657, 0xB3A6, 0x63D9, 0xE933, 0xFB2E, 0xDD83, 0x06E0,
+    0x74C1, 0xB2AA, 0x7A0E, 0x0B7B, 0xB9B5, 0x6A1A, 0xED76, 0x4DAB, 0x5477, 0xCD5D, 0xDBF2, 0xA7C7,
+    0xA3C0, 0x0724, 0x0162, 0xF71C, 0x3CEB, 0xB387, 0xE3EC, 0x3663, 0x9E39, 0x4A6B, 0x68CF, 0x3539,
+    0xD55E, 0xF956, 0xCDEE, 0x28F0, 0x0049, 0x800C, 0xC838, 0x76F5, 0x5CDD, 0xE598, 0xEE0C, 0xE8DD,
+    0x3DBB, 0x0676, 0xAC82, 0xAB1F, 0xAFF5, 0xD869, 0x0778, 0xA6E5, 0xB0E6, 0xB09C, 0xC3A1, 0x9D35,
+    0xD65B, 0xC078, 0x8024, 0x40BA, 0xC6AE, 0xB28A, 0xD355, 0x9C35, 0x781A, 0x6655, 0xB97A, 0x6D97,
+    0xD0A9, 0xEE61, 0xCFE2, 0x1A67, 0x0249, 0x8040, 0xCD57, 0xA776, 0xFAB6, 0x4497, 0x5AAB, 0xBAAC,
+    0xC1A9, 0xB11C, 0x05ED, 0xBE05, 0x9200, 0x019F, 0x35BB, 0xEAD4, 0xAC53, 0x3DD3, 0xDDC0, 0x9C76,
+    0x69C9, 0xEFD0, 0xE1DD, 0x6BF7, 0xE8D1, 0xA31C, 0xADD5, 0x2920, 0x0910, 0x61D7, 0xDC8E, 0x12CA,
+    0xD7B4, 0xCBD6, 0xDEF1, 0xB457, 0xBB9D, 0xA7BF, 0x81C0, 0x0724, 0xF07F, 0x3BFF, 0xBBB5, 0x6F7D,
+    0x553D, 0x2100, 0x4078, 0x0E98, 0x4131, 0x9E07, 0x9017, 0xB67E, 0x0712, 0xC750, 0x7A37, 0x8720,
+    0x00AB, 0xEFDE, 0xEAAE, 0xD5D3, 0xF600, 0xB05F, 0x77F8, 0x8404, 0x9649, 0x75E4, 0x87C3, 0xC788,
+    0x5C3B, 0xF147, 0x32D3, 0xE3B1, 0xF371, 0x286D, 0x742E, 0xF025, 0x0E11, 0x25C0, 0x301A, 0xDF71,
+    0x95E7, 0x3260, 0xDBD3, 0x6FD6, 0xEBC3, 0x613F, 0xB6D9, 0x817C, 0xEC7E, 0xEDB7, 0xEB1E, 0x5CEB,
+    0x55A4, 0x5679, 0xF8F0, 0x436D, 0xACAA, 0x1654, 0xF4A7, 0x2EB7, 0xDED3, 0xCE7D, 0x01BA, 0xBCE6,
+    0xA687, 0x10EC, 0xE092, 0x2FE6, 0xA111, 0x3343, 0x28D0, 0x4120, 0x8096, 0x8B4F, 0x7BF0, 0x4580,
+    0x4D38, 0xDC45, 0x8C28, 0x6846, 0x7163, 0x10AA, 0x02FE, 0x804B, 0x0310, 0x029B, 0x7413, 0x072A,
+    0x2024, 0xBF46, 0x0C17, 0x6012, 0x0CD0, 0xDD4D, 0x20C4, 0x26E5, 0xD9A5, 0x0FB0, 0x8FC5, 0xCCC0,
+    0x744C, 0x7642, 0x882B, 0x87CA, 0x39B6, 0xE751, 0x3F6A, 0x4533, 0x6C75, 0x9BBC, 0xABD6, 0xC110,
+    0x05FF, 0xAA95, 0xE150, 0x0EFF, 0x5D8F, 0x78B4, 0xEF7C, 0x767D, 0xE0DF, 0xCFCC, 0x20DE, 0x001C,
+    0x90DD, 0x7507, 0x474C, 0x1E7E, 0x6C0C, 0xAF0F, 0xCA63, 0x1434, 0xEAB9, 0x454D, 0x2322, 0x2446,
+    0xE7EF, 0xC761, 0x44C0, 0xE1E6, 0x89DC, 0xA3FA, 0x80EC, 0xAE33, 0x2E02, 0x18D2, 0x09EF, 0x3708,
+    0x00D7, 0x0640, 0x7B48, 0xEDDC, 0xB90B, 0xBF6F, 0xA956, 0xF4E1, 0x8309, 0x1300, 0x803D, 0x0076,
+    0x6067, 0x165A, 0x62A6, 0x78F1, 0x9C59, 0xDE45, 0xA112, 0x4F5D, 0x1947, 0x5D46, 0xAF83, 0xF042,
+    0xA174, 0x9C53, 0xFB3A, 0xF7E1, 0xE188, 0xA6AB, 0xCCA2, 0x515B, 0x3566, 0xF515, 0x9783, 0x4FE8,
+    0x2A6B, 0x8F7B, 0xFE3A, 0x1171, 0xB4B2, 0x9FC3, 0x9999, 0x669A, 0xE66B, 0xDE9D, 0x234B, 0xAAAE,
+    0xE99A, 0xAEA9, 0xDA5A, 0xB2DF, 0x87EB, 0x996E, 0xE9D5, 0xED36, 0xAFA6, 0x18F4, 0x743A, 0x31F3,
+    0x6822, 0x723E, 0x115B, 0xDF2A, 0xEF3A, 0x7E1C, 0xA1B5, 0xE253, 0x9DBA, 0xC2F3, 0x7C9F, 0x4AD1,
+    0xBF8C, 0x0A00, 0x7400, 0x800A, 0x1300, 0x0000, 0x78D5, 0x754E, 0xCB80, 0x1CB9, 0xB1FA, 0xBDA0,
+    0x6F67, 0x8E6B, 0xDD73, 0xF76E, 0xB47A, 0x8D9C, 0x7B66, 0xC554, 0x388E, 0x7D68, 0x7065, 0xE074,
+    0xAC69, 0x0AED, 0xD9B3, 0x5574, 0x177B, 0xE788, 0x172D, 0xB65E, 0x3EA1, 0x5E57, 0xA112, 0xB12A,
+    0xCDA4, 0x652B, 0xDD42, 0x56B9, 0x4256, 0xA68F, 0x9A60, 0xAF2D, 0x52A3, 0xBA55, 0x31FD, 0x916B,
+    0x0BA5, 0x3D66, 0x7F18, 0xB3EB, 0xB563, 0x553F, 0x5959, 0xAE5D, 0x3B75, 0xC0E8, 0xCB74, 0x6798,
+    0x1E35, 0xC137, 0x77FF, 0xDC4C, 0x30D1, 0x0ED0, 0xD013, 0xF9B4, 0xD9E5, 0x0400, 0x00A8, 0x3001,
+    0x0000, 0xE419, 0xC4AF, 0x0B15, 0xCAF7, 0xC973, 0x4E99, 0x1995, 0x8895, 0xD06A, 0xA84C, 0xA7E2,
+    0x45D5, 0x6CD7, 0x3199, 0xA17B, 0xD195, 0x0D6E, 0x1BC9, 0xE5AD, 0xC26F, 0xACBA, 0x6BEF, 0xB1A3,
+    0x9CBC, 0x9383, 0xD7E1, 0xACAA, 0xA917, 0xB3BE, 0x9067, 0xD543, 0x0DE3, 0x44BF, 0x97BD, 0xEECE,
+    0x7CF9, 0x7AF3, 0x63E8, 0xEF4C, 0xD5F4, 0xDDD4, 0x6B8C, 0xA3B0, 0xE72E, 0x33FC, 0xAAF4, 0x9F8B,
+    0x4778, 0xF77C, 0xC778, 0xBCB7, 0x857E, 0x72FE, 0x2D7F, 0xA503, 0xE7D7, 0xEF7A, 0x1709, 0x99BE,
+    0x987D, 0xAD71, 0x4340, 0xEF03, 0x0000, 0x5498, 0x0000, 0x0000, 0x801D, 0xC89B, 0xEDFC, 0x8A2F,
+    0xB341, 0xE377, 0xE28E, 0xEFB9, 0xCE63, 0x3DCC, 0xF437, 0xD7B9, 0x57EF, 0xEA3A, 0xA346, 0x3B7E,
+    0x711D, 0xD771, 0x1DD7, 0x344C, 0xE390, 0x13E9, 0x6362, 0xD6F3, 0x2734, 0x6924, 0xE368, 0x7269,
+    0xFBF2, 0x34AD, 0xB747, 0x5BCF, 0xE96D, 0xACB7, 0x4BAE, 0xD29D, 0xEA67, 0x78DD, 0xCF56, 0x5D43,
+    0xCA9A, 0x97F1, 0x3BAD, 0xC07D, 0x60AD, 0x8C96, 0xCF16, 0xF4DF, 0xA131, 0x62FC, 0x5763, 0xA0FD,
+    0x2C30, 0x0100, 0x0050, 0x017F, 0xDC3A, 0xA827, 0xE420, 0x07E1, 0x634E, 0x477A, 0xABA2, 0x2ADD,
+    0x258C, 0x9671, 0xF275, 0x47BD, 0x7BCF, 0xBCAE, 0xE1CE, 0x11C2, 0x6AEE, 0x1C68, 0x4159, 0x5446,
+    0x2055, 0xC54B, 0x758F, 0x4AEA, 0x73A0, 0xE4B9, 0x7198, 0xF444, 0x05D4, 0xFC49, 0xFAA5, 0x7BFE,
+    0xE67F, 0xEEA8, 0x382B, 0x94C1, 0x6979, 0x00F8, 0x3130, 0x7DF5, 0x0C77, 0x02A2, 0x61D5, 0xB033,
+    0x3C40, 0xBAA6, 0x3802, 0x6106, 0x290F, 0x00F0, 0x6652, 0xB8AF, 0x3410, 0x5CAB, 0x4CC7, 0x10DA,
+    0xC839, 0x7D9E, 0xCF83, 0x4BB9, 0x79EE, 0xB8DF, 0x1ABD, 0xDEFA, 0xF33F, 0xC277, 0x6A44, 0xF4AF,
+    0x6855, 0xD52E, 0x7CF8, 0xA16A, 0x0D8E, 0x35C8, 0x4BA1, 0x1888, 0x1C51, 0x75BB, 0xB70E, 0xA201,
+    0x6B5C, 0xB418, 0xF32F, 0x039C, 0x4785, 0x74F8, 0x1815, 0xB554, 0x473E, 0x60AF, 0x4F23, 0x937F,
+    0x12B6, 0xD3FB, 0xBBB1, 0x1F1C, 0x5514, 0x22CF, 0xF995, 0x0F0F, 0xCCCD, 0x5CC3, 0x21E9, 0x4511,
+    0xCED5, 0xA807, 0x3938, 0xE4D5, 0x337B, 0x9CA2, 0x512D, 0xF8F0, 0xFFDE, 0xA9D2, 0x8375, 0x4042,
+    0xFAE5, 0x6E98, 0x496C, 0x54A8, 0x0AC5, 0x33ED, 0x6662, 0xD0C7, 0x33E6, 0x4586, 0x002B, 0x3538,
+    0x9DC6, 0x89E9, 0x3CC5, 0x3C11, 0x9492, 0xF590, 0xF840, 0x8E11, 0xD208, 0x3302, 0x9F9A, 0xFBA6,
+    0xBD0B, 0x83DA, 0x3CF0, 0x008A, 0x2201, 0xEC17, 0x24AB, 0xD5A1, 0x5BE9, 0x9620, 0x8E10, 0xDCB8,
+    0x5F63, 0x98C7, 0x48E4, 0x5B8D, 0x201F, 0xCF91, 0x8303, 0x0C68, 0x8070, 0x8890, 0x07E0, 0x610A,
+    0xEBE2, 0x2DDD, 0x8C9F, 0x9901, 0x9BE1, 0xED70, 0xBA5E, 0xA618, 0x6176, 0xFF3E, 0x7DDC, 0x6E1F,
+    0x994B, 0x13BF, 0xED42, 0x59F0, 0x7D22, 0xDB16, 0x8A6C, 0x5BC8, 0xB645, 0x21DB, 0x1610, 0x3F81,
+    0x8038, 0x1047, 0xFC20, 0x8E20, 0xE288, 0x0802, 0x11C4, 0x4144, 0x9020, 0xE288, 0x1F5E, 0x4924,
+    0x0E89, 0x9FBC, 0x725D, 0x595C, 0x3F58, 0x5C97, 0xFC12, 0x7225, 0x81FF, 0xAB78, 0xFD07, 0x07E8,
+    0xC7A1, 0x4CDC, 0x2BD4, 0xAD53, 0xB516, 0x7C5E, 0x6102, 0x0090, 0x0A60, 0x1332, 0x9192, 0xBF9B,
+    0xF7D8, 0x4797, 0x7ABC, 0x7FA6, 0x1AC1, 0xCF8C, 0x70F7, 0x8AA5, 0xA716, 0x51DB, 0x0785, 0xC93B,
+    0xA72B, 0x7E84, 0xAA56, 0x56A5, 0x96A6, 0x6A1D, 0xA56A, 0xFC18, 0x31E3, 0xC4D7, 0x5497, 0x31C6,
+    0x94BB, 0xE7F0, 0xF18F, 0xBC95, 0x3C73, 0x24C4, 0x736A, 0xA25F, 0x4F33, 0x8754, 0xCBA2, 0x1BE6,
+    0xD6CD, 0xD47D, 0xB186, 0x30B7, 0xCE98, 0x25F7, 0x0CCE, 0x1AD6, 0xF384, 0x2EEC, 0x9E26, 0x7E05,
+    0x70AC, 0xA999, 0xCA55, 0xCE26, 0xD2BF, 0x3E5F, 0xBB71, 0x1EDD, 0x95DD, 0x7E9E, 0xD344, 0x76CA,
+    0x236B, 0xB5A8, 0xCC2F, 0xA890, 0x6DB3, 0xBF02, 0x34D9, 0xA003, 0x0000, 0x4085, 0x0900, 0x0070,
+    0xBEDE, 0x3BF4, 0xDEEF, 0x0670, 0xBE9D, 0x003A, 0xB614, 0xE573, 0x5F05, 0x4E42, 0x02C0, 0xF9B9,
+    0xE6D5, 0x0970, 0xBEBD, 0xCBDD, 0xCA09, 0x709E, 0x1603, 0x5950, 0xDE05, 0x1F5E, 0x0180, 0xF3ED,
+    0x64A5, 0xEC15, 0x0F00, 0x009C, 0xAF49, 0x435A, 0x8F38, 0xC6B7, 0x02C0, 0xF976, 0x02EC, 0xAAC6,
+    0xB713, 0x7EC7, 0xCABB, 0x2FD0, 0xBF5E, 0xE7EA, 0xFB31, 0x70EE, 0x98CF, 0xA706, 0x2533, 0x481B,
+    0x6BEF, 0x9CCB, 0x174E, 0xF57B, 0xF6D1, 0x9CAA, 0x30D5, 0x336E, 0x19F2, 0x578B, 0x6ED7, 0x1AC1,
+    0x6774, 0x5167, 0x00BD, 0x20B2, 0x16B9, 0x56F9, 0x01E0, 0xFC77, 0xB36C, 0x2F00, 0xCEB7, 0x13E0,
+    0x7C3B, 0x01BA, 0xF3DB, 0x35E9, 0x0400, 0xB401, 0x80FE, 0x9E33, 0xEEC8, 0x111B, 0x6AFB, 0xF350,
+    0x566D, 0x10F2, 0xA2D6, 0xBFB7, 0x35DB, 0xDFD5, 0x09A0, 0xC7D9, 0x5F64, 0x87F9, 0xEE9E, 0xFD3A,
+    0x7E7D, 0x874E, 0x0044, 0x0050, 0x6102, 0x0000, 0x75B5, 0xAC92, 0x9F89, 0xDE3B, 0x6744, 0x663E,
+    0xA9C4, 0x39AB, 0x9424, 0x79D8, 0x0FAB, 0xE7A6, 0x42DB, 0x3A05, 0x56CB, 0x4D83, 0x0600, 0x4885,
+    0xD175, 0xFFAE, 0x1AEB, 0xFE57, 0x1AF2, 0xE738, 0x153E, 0x22C9, 0xC77B, 0x47CE, 0xA339, 0x9EA3,
+    0x26BA, 0x6F91, 0x55F2, 0x33A0, 0x01CA, 0x1B24, 0x7B03, 0x80D4, 0x3D94, 0x24F9, 0xDE7B, 0x0268,
+    0xB524, 0xAB1E, 0xF5E1, 0x9274, 0x9E57, 0x05B2, 0xBF94, 0x93A5, 0xEB5D, 0x3632, 0x46E4, 0xBDAF,
+    0x7C0F, 0xEF59, 0xCDC6, 0x8FD1, 0x5F17, 0xD065, 0x4992, 0xE4DA, 0x78CE, 0x1AD0, 0x6EC9, 0xB5C5,
+    0xE54A, 0xBA92, 0xAEDE, 0xDEF0, 0x1200, 0xB001, 0xC9BB, 0x7F64, 0x43CB, 0xFD06, 0x13EE, 0x36FA,
+    0x8FCE, 0xD320, 0xF95E, 0xE6BB, 0xA724, 0xE3DE, 0xBB47, 0xCFDD, 0x9264, 0x9C9E, 0xB8A7, 0x5E7E,
+    0x45F5, 0xD7C4, 0x2579, 0x6779, 0x7317, 0x9FD3, 0x515E, 0xBE87, 0xF7AF, 0x6547, 0xD338, 0xEF2A,
+    0x6023, 0xC738, 0xD7C0, 0x3891, 0x1320, 0x1747, 0x0054, 0xC09F, 0x5725, 0x7C09, 0x00D4, 0xC3FE,
+    0x6420, 0x7010, 0x1CB7, 0xB943, 0xE62D, 0x7D70, 0x4C24, 0xD37E, 0x4D51, 0x88A7, 0x13A9, 0x7D87,
+    0x4952, 0x1C9A, 0x546B, 0xA76A, 0x79F8, 0x0008, 0x4A80, 0x005D, 0x4E21, 0x01DE, 0xD67B, 0xAC01,
+    0x4FB9, 0x21D9, 0x6E88, 0x9665, 0xDB90, 0x3087, 0x0E60, 0x42DA, 0x360A, 0x0910, 0x17BA, 0xDD56,
+    0x5DED, 0xB73C, 0xFECC, 0x7126, 0x64FB, 0x4102, 0x2440, 0xC6DE, 0x6EE0, 0x13F6, 0xAABE, 0x61CC,
+    0x6E81, 0x7BD6, 0x5EC0, 0x0F24, 0x0102, 0xDFDA, 0x652F, 0x60E1, 0x555D, 0xD633, 0x02FC, 0xDDB6,
+    0xF50C, 0x6077, 0x6A69, 0x3D90, 0x9000, 0x2400, 0xCC72, 0x4C88, 0x0BF8, 0xD7BD, 0xF9E3, 0xF00D,
+    0x10A0, 0xAD05, 0x09DB, 0xCF4F, 0x27C0, 0x3DD4, 0xD373, 0x4217, 0x702D, 0xB846, 0x6955, 0x80F1,
+    0xD48A, 0xF5F5, 0x1900, 0xE303, 0x9200, 0xF9EB, 0xAA2E, 0xEB19, 0x01C3, 0xAAB2, 0x1E9F, 0xB2BA,
+    0x2E81, 0xB5FA, 0xAA6A, 0xAE01, 0x2424, 0x0009, 0x0009, 0xE38D, 0x4D77, 0x2FC0, 0x0001, 0x4AB7,
+    0x2450, 0xFDE8, 0x99A3, 0x4709, 0x749B, 0x6FA6, 0xEB2A, 0x7EC6, 0x3B53, 0xAB33, 0xEE76, 0x090B,
+    0x4802, 0x04F0, 0x2EE4, 0xF4AC, 0xD3C0, 0x93F1, 0x94D5, 0x75FA, 0x8784, 0x0420, 0x0120, 0x6157,
+    0xE66C, 0x80BF, 0xA60B, 0x0810, 0x78CA, 0xE522, 0x8135, 0x1C4F, 0x2F80, 0xD97D, 0x4C65, 0xF67A,
+    0x0761, 0xD76D, 0x55F5, 0xB37B, 0xAE08, 0x4002, 0x3FBE, 0xEEDB, 0x35F4, 0xDEF7, 0xDEF5, 0x3EB4,
+    0xBF57, 0xEFDF, 0x7D55, 0x756C, 0xDD7B, 0xFFFE, 0xDDD7, 0xBBEB, 0xADDE, 0xF51E, 0x3E7C, 0xB842,
+    0x0F55, 0xAD87, 0xAA61, 0x55F8, 0xF0E1, 0xC3EB, 0xDD76, 0xC71A, 0x7E7C, 0xEFDF, 0xF77A, 0x91BA,
+    0x7877, 0xEB5D, 0x54F5, 0x2EFC, 0x6D61, 0x0200, 0xA0BC, 0x4F15, 0xE8BF, 0x394B, 0x1CED, 0xB9B5,
+    0xA0AD, 0xAF5D, 0x5642, 0x9260, 0xD53C, 0x34EC, 0x9C0A, 0x39D1, 0xC67E, 0xF8DC, 0x9354, 0x6850,
+    0x96A7, 0xC227, 0xF67F, 0x0789, 0x31D7, 0x2AC7, 0x7B0E, 0x2579, 0xCFEB, 0x4258, 0x779D, 0x38D9,
+    0xA47D, 0x068C, 0xF288, 0xEA4C, 0xA00F, 0x0028, 0x6F90, 0xEC0D, 0x0052, 0xF750, 0x92DC, 0x0090,
+    0x87B2, 0x3FE6, 0x7AD0, 0xDFA9, 0xE2FB, 0x90F9, 0xF229, 0x79B8, 0xFB44, 0x13B7, 0x3154, 0x75F2,
+    0xC505, 0x802E, 0x4B92, 0xE419, 0x2F7A, 0xC21A, 0xB403, 0xD64A, 0x4ED6, 0x6055, 0x41C1, 0x65FE,
+    0x6FBD, 0x76CC, 0xEFC4, 0x0990, 0x97AB, 0x5194, 0x31CF, 0xD8A3, 0xAB13, 0xBFB7, 0x9F92, 0x51CE,
+    0x5CA5, 0x5B6E, 0x6EE6, 0x4ECC, 0xFB02, 0xD13A, 0xFB1B, 0x0090, 0x097E, 0x8B7C, 0xDB03, 0x39B3,
+    0xAD5B, 0xDE7B, 0x9F7B, 0x354B, 0x8ED0, 0x88F3, 0x9E57, 0x0DF9, 0xE9D9, 0xEE66, 0xE578, 0x1500,
+    0x0015, 0x2600, 0x0000, 0x1268, 0xBEB1, 0x8877, 0xBF2D, 0x99E5, 0x3EEE, 0xA021, 0x7395, 0xFDB5,
+    0xDBA9, 0x79F7, 0x4292, 0x7CC4, 0xC16B, 0xBC8B, 0xF4E5, 0xBC31, 0xFAFD, 0xEF02, 0x6377, 0xEF27,
+    0x0028, 0x6F90, 0xEC0D, 0x0052, 0xF750, 0x92DC, 0x0000, 0xF37B, 0xDE80, 0x9A95, 0xF962, 0x6FBD,
+    0x7BDE, 0x9C78, 0x9224, 0x9318, 0x65F5, 0xFC7B, 0xE403, 0x233D, 0xA55A, 0x4408, 0x4097, 0x2549,
+    0xF2AD, 0xF96A, 0x403B, 0xB45B, 0xBE35, 0xC065, 0xFE6F, 0xED1F, 0x23BE, 0xA5F2, 0x4BD4, 0x00C0,
+    0x329B, 0x762C, 0x03E9, 0x639D, 0xBBB7, 0x8EFE, 0x0CCA, 0xAAB4, 0x47AC, 0x96C5, 0xA59E, 0x066D,
+    0x6395, 0xF29E, 0xCF81, 0x4E00, 0x80BC, 0xD534, 0x90BF, 0x3A7D, 0xCEB9, 0x142C, 0xE4EB, 0x7722,
+    0x99FB, 0x73DF, 0x38B5, 0x7C9A, 0xDFE4, 0x167D, 0x6FA8, 0x0000, 0x1526, 0x0000, 0xD0CE, 0x07FC,
+    0xDA6A, 0xB1C6, 0x9DB0, 0x4243, 0xD759, 0xF09E, 0x6F9E, 0x668F, 0xDC77, 0xCD32, 0xEF73, 0x1788,
+    0x1F73, 0x45D6, 0xCC41, 0x433B, 0x0100, 0x80F2, 0x5E48, 0xF606, 0x00A9, 0x7B28, 0x49B2, 0xF659,
+    0x71E0, 0x0038, 0x794F, 0x4E24, 0x27AD, 0x94CF, 0x0828, 0x992D, 0x92EF, 0xA937, 0xBBEE, 0x05FA,
+    0xF7C9, 0x5AEF, 0x23E7, 0x1B72, 0x9457, 0xA3A2, 0xFFAE, 0xA0CB, 0x9224, 0xC9D1, 0x6A39, 0xDE77,
+    0x2377, 0x660E, 0x48EE, 0xAAE4, 0x24D1, 0xFF60, 0xE858, 0x3A96, 0xCECC, 0x0090, 0x0AED, 0x3053,
+    0x9F8E, 0xF55F, 0xA07F, 0x17AC, 0xF63A, 0x7257, 0x538C, 0x5D91, 0x64AE, 0xE7AD, 0x29BF, 0x676F,
+    0xE5E4, 0x547D, 0xF7CA, 0xACEA, 0x65EC, 0x95AC, 0x48CE, 0xB677, 0x0AE4, 0x7390, 0x24EF, 0x3ED7,
+    0xFBC4, 0x84B3, 0xEAD0, 0xF8F1, 0xFCC5, 0x47FA, 0xF767, 0x8FAB, 0xD604, 0x0000, 0x2AE0, 0x4355,
+    0xE586, 0xBA0A, 0x5EAB, 0x850F, 0x1F3E, 0x7CA8, 0x063D, 0x7CBE, 0xBFBF, 0x6F15, 0xAE50, 0x0D55,
+    0x413D, 0x7CF8, 0x7A59, 0xEB78, 0xA82A, 0x7CF8, 0xF0E1, 0xC36A, 0x3DD4, 0xE1C7, 0xFBFD, 0xAB0E,
+    0xABA0, 0x1A56, 0x857A, 0xF8B7, 0x1320, 0x4BE2, 0x6DA6, 0xEE01, 0x5ED5, 0x655F, 0x0290, 0x9000,
+    0x2400, 0x5C8B, 0x2564, 0x829C, 0x5DCF, 0xD0E3, 0xB4EB, 0x3240, 0x0087, 0x0EAB, 0x9240, 0x92ED,
+    0xE7E7, 0x7641, 0xC653, 0x4FD7, 0xDC93, 0x0716, 0x57AA, 0xBA06, 0x5CC5, 0x3D80, 0xBB3F, 0x2B4B,
+    0xE003, 0x925A, 0x136E, 0x672B, 0x1B08, 0xC471, 0x0D01, 0x8D6D, 0x4308, 0x2463, 0xCF82, 0xCC32,
+    0xF08D, 0xAF16, 0x8440, 0x0864, 0xBBF7, 0x8038, 0x8017, 0xF81C, 0x77D7, 0x8685, 0xDD73, 0xC05A,
+    0x3DAF, 0x0103, 0xF881, 0x1F38, 0xC31E, 0x0EE0, 0x14CF, 0x70F0, 0x0E79, 0x9A77, 0x085C, 0xC3E2,
+    0x1F3C, 0x0AA4, 0x268F, 0xFC45, 0xE9A2, 0x6B8D, 0x099C, 0x6117, 0x7054, 0xE06A, 0xE01A, 0x96C0,
+    0x3D04, 0x7BF4, 0xC838, 0x0EE0, 0x6EE0, 0x2D4A, 0xFE5A, 0x05BF, 0x7BA8, 0xC02F, 0x700F, 0x81A7,
+    0x810C, 0x4701, 0x194E, 0xE0B3, 0xD69C, 0xD339, 0xA6CE, 0x1ABA, 0xDA1E, 0xE5AC, 0xBB4E, 0x395A,
+    0x4795, 0x3DAA, 0x966D, 0x770D, 0x47DB, 0xAE1E, 0x55D3, 0xF21E, 0xD6AC, 0x39AC, 0xD9A3, 0x75D4,
+    0xEC51, 0xCEBA, 0x470D, 0x87C3, 0x5135, 0x1C0E, 0xC733, 0xD61A, 0x8E6D, 0x8DED, 0x7074, 0x2A8E,
+    0x1E76, 0x8F39, 0x346B, 0x38A6, 0xEDD1, 0x3147, 0x8F35, 0xDC5A, 0x0E1D, 0x7B38, 0xD61A, 0x67D9,
+    0x35A7, 0xE5F0, 0x3E63, 0xEFE3, 0x1CDE, 0xB3D4, 0xEAD1, 0xA566, 0xB467, 0x0DC7, 0x331C, 0x3D1C,
+    0x7BB4, 0x6B38, 0x66ED, 0xD163, 0x0FC7, 0x1A73, 0x1CE7, 0xB0D4, 0xB287, 0xDACE, 0x51A3, 0xC699,
+    0xB719, 0x35F6, 0x70EC, 0x6159, 0x6A6D, 0xE7A8, 0xB1ED, 0xB2E6, 0x74D4, 0x70F4, 0x98C3, 0xF10C,
+    0xAB47, 0x8DBD, 0xACDA, 0x8E35, 0x7ACC, 0xE1B8, 0xC65A, 0xC3B1, 0x4A5B, 0xADD9, 0xBA56, 0xAB23,
+    0xB586, 0x434B, 0xC71C, 0xCEB6, 0x9DC7, 0xB9D4, 0xD153, 0x2DC7, 0x1CA5, 0xE358, 0xD535, 0xDAD6,
+    0xDDD6, 0xB8A6, 0x6BD4, 0xE872, 0xDC6B, 0x389E, 0xE168, 0xDDA3, 0xC71E, 0x8E59, 0x7BF4, 0xD8C3,
+    0xB1C6, 0x1CC0, 0x812F, 0xAD82, 0x5655, 0x870F, 0x1FFE, 0xBFDB, 0xD586, 0xAA0A, 0x3EBF, 0xEDFE,
+    0xBB0F, 0x5F58, 0x1DFB, 0xAABF, 0x4DAB, 0xE0E1, 0xBF12, 0x9800, 0x7E59, 0xEBDE, 0xE5DB, 0xDE9E,
+    0x9FB1, 0x0460, 0x67AF, 0x0770, 0x79FF, 0xF00A, 0x4CEC, 0xC21A, 0xAC03, 0x7079, 0x3A00, 0x97A7,
+    0x435E, 0x1600, 0x48DD, 0x43E3, 0x7F2B, 0xB4A1, 0x0EC0, 0xE5E9, 0x005C, 0x46C4, 0xD395, 0x7AB9,
+    0x01B8, 0xBCEF, 0xA10F, 0xE4A6, 0xBD9F, 0x9B7D, 0xFC6F, 0xAD0F, 0x00E8, 0xB2BD, 0x280B, 0x7500,
+    0x2E4F, 0x07E0, 0xF274, 0x002E, 0xC74A, 0xC4D3, 0xB500, 0xC8D0, 0x0100, 0x0072, 0x46AC, 0x578E,
+    0xB86E, 0x4E1F, 0xA4CF, 0x7823, 0xAD78, 0x8F0E, 0xE032, 0x7F4B, 0x8CB3, 0xFB8D, 0x2C0D, 0x7DC0,
+    0x658C, 0x478D, 0xD9F5, 0xF2FC, 0xF2FE, 0xBBDD, 0x9123, 0x2E08, 0x7400, 0x0040, 0x0500, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x0000, 0x5801, 0x0035, 0xF30D, 0x8CC8, 0x7C99, 0x6F00, 0xC088, 0x5401,
+    0x648C, 0x4C01, 0x1923, 0x017D, 0x5522, 0x0520, 0x6324, 0x00E8, 0xCB7C, 0x0315, 0x9001, 0x9C4C,
+    0xCF6F, 0x007C, 0x7EFC, 0xDAC8, 0xF856, 0x80DF, 0xAF01, 0x64AF, 0x91BF, 0xC177, 0xDDB4, 0x1334,
+    0xA00F, 0x0020, 0x6364, 0xFA46, 0xFE18, 0xF9E3, 0xD706, 0x808C, 0xF5F3, 0x9F7C, 0x0300, 0x3E3F,
+    0x4647, 0x2600, 0xA8E7, 0x271E, 0xDFC2, 0x6A00, 0xC0CA, 0xF90D, 0x1A99, 0xF016, 0x0F30, 0xE0BB,
+    0xD203, 0x0018, 0x77F1, 0x7B05, 0x00C6, 0x5DFC, 0x0DBE, 0xAB01, 0x34EC, 0x04C0, 0x49F8, 0x2EFE,
+    0x181D, 0x7012, 0x0034, 0xCECF, 0x0200, 0x56CE, 0x6F00, 0x8CBB, 0xF8BD, 0x0200, 0x8DCC, 0x3730,
+    0x0040, 0x3D3F, 0xF1F8, 0x167F, 0x0C01, 0x008D, 0x37E8, 0x583F, 0x56EE, 0xAA78, 0x833E, 0xAE5F,
+    0x039F, 0x023B, 0x62A0, 0x018D, 0x18A8, 0x6FD4, 0x38AD, 0x02D7, 0xA0A7, 0xCCA5, 0x8FD8, 0x0F56,
+    0xEE92, 0x1D50, 0xDFA0, 0x5512, 0x6F64, 0xACD1, 0x0119, 0xEB5F, 0x712C, 0xADF2, 0x061A, 0x768D,
+    0x0E58, 0xB94B, 0x7640, 0x7D63, 0x2F3D, 0xC503, 0x196F, 0x818F, 0x8FBE, 0x3768, 0x0734, 0xECBB,
+    0xBA94, 0x6BB4, 0x903D, 0x3905, 0x8EA5, 0x6B74, 0xC4C0, 0xDBF5, 0x6995, 0x3790, 0x8106, 0x3420,
+    0x23BE, 0x41D7, 0xA063, 0xE929, 0xE5BB, 0xBA64, 0xC05B, 0xACF2, 0x061A, 0x768D, 0x7EB0, 0x7297,
+    0xEC80, 0xFA06, 0xAD92, 0x7823, 0x03D9, 0x89D8, 0x68D8, 0x0E40, 0xC376, 0x40C6, 0xC837, 0x909D,
+    0xB01D, 0xD0B0, 0x633D, 0x23F2, 0x0D54, 0xFBF8, 0x788B, 0x6BA8, 0xFC7E, 0xFE93, 0x6FA0, 0x0119,
+    0x23EF, 0xDA4B, 0xD76F, 0xEF92, 0x1D70, 0xD2EE, 0x1473, 0x5D05, 0x7640, 0xC6C8, 0x3436, 0x2E3B,
+    0xA061, 0xC7FA, 0xD190, 0x3190, 0x3D89, 0xCC07, 0xBF41, 0x1FF1, 0x0027, 0x6D95, 0xABE2, 0x0DCA,
+    0x6F2B, 0xD51E, 0x2063, 0xAF57, 0x9E02, 0x3BA0, 0x613B, 0x6223, 0x7B12, 0xA9E2, 0x818C, 0xD39D,
+    0xF9E6, 0xD2B1, 0xF4B1, 0xB463, 0x7DC7, 0xE921, 0xE37D, 0xFA6D, 0xE553, 0xE82B, 0x9F0F, 0xD7CF,
+    0x0FD7, 0x883C, 0x053E, 0x6207, 0xE02D, 0x8EA5, 0x6BA8, 0xFC7E, 0xFE93, 0x6F20, 0x63E4, 0x5D7B,
+    0xE9FA, 0xED5D, 0xB223, 0xD3EE, 0x1473, 0x6915, 0xD801, 0x1923, 0xD3D8, 0x0940, 0x43C6, 0x4023,
+    0x361A, 0xB603, 0x3246, 0x6EB1, 0x85BE, 0xF3F7, 0x5276, 0x40C3, 0x8EA5, 0x3B21, 0x3BF1, 0x06ED,
+    0x8086, 0xEDC8, 0x7C03, 0xF80D, 0x5A1F, 0xAEAF, 0xF21B, 0xB423, 0xD356, 0xD157, 0x813B, 0x6BD0,
+    0x9DF9, 0x6CFD, 0x1B77, 0xF19F, 0xB4EB, 0x8BBE, 0xCC7C, 0x8046, 0x6646, 0x6C7C, 0x7E02, 0x27CF,
+    0xA778, 0x8093, 0x7627, 0x54BB, 0x1332, 0x66F1, 0x4623, 0x131A, 0xF01B, 0x7427, 0x649C, 0x1E20,
+    0x6316, 0xC898, 0x25D2, 0x56B9, 0x710A, 0xEC90, 0x94AA, 0xA07C, 0x977C, 0x975C, 0x831E, 0x2063,
+    0x6406, 0x648C, 0xCC80, 0xDFA0, 0x07C8, 0x387D, 0x5785, 0x3C05, 0x9E02, 0x276D, 0x07E5, 0x92EF,
+    0xAA90, 0xA7C0, 0x5320, 0xE374, 0x0D7A, 0x808C, 0x9119, 0x909D, 0xB01D, 0xD0B0, 0x3BA1, 0x611F,
+    0xB143, 0x2FD3, 0xEE84, 0x9390, 0xB197, 0x3EAE, 0xF18A, 0x074E, 0xC278, 0x23FF, 0x7D31, 0x4E3B,
+    0xE0E4, 0x1BC8, 0x9825, 0x52C0, 0xE5B7, 0x1390, 0x8DEC, 0x35E8, 0x58F7, 0xAA07, 0x8DD8, 0xC846,
+    0x031A, 0x9081, 0x9376, 0x9281, 0x0634, 0x009F, 0x0FD7, 0xC80F, 0xDF15, 0x7C97, 0x6C33, 0x6D07,
+    0x6427, 0x62A3, 0xDA9D, 0xF96C, 0x951B, 0xE7C3, 0x35E8, 0x4EE8, 0xAB12, 0x990F, 0x2EDF, 0x15E5,
+    0xBBE4, 0x1A74, 0xD280, 0x0C9C, 0xB41D, 0x92D2, 0x90A7, 0xC00E, 0x5B05, 0x1E3C, 0x3020, 0x032B,
+    0x912A, 0x70F9, 0x0D8C, 0x720D, 0xD1C8, 0x7C03, 0x8DD8, 0x68D8, 0x0EC8, 0x18B9, 0x45B6, 0xD077,
+    0xFE5E, 0xDA01, 0x0D3B, 0x96EE, 0x84EC, 0xC41B, 0xB403, 0x1AB6, 0x23F3, 0x0D00, 0x00EA, 0x5AFB,
+    0x3ED4, 0x5FF5, 0xF7AF, 0xFDEA, 0xA7BF, 0x7FFF, 0xDAA1, 0xFF77, 0xEA57, 0x7DD5, 0xE001, 0x00A0,
+    0xFE5E, 0xA157, 0x6B6B, 0x7BAF, 0xDADD, 0x579B, 0xFCF7, 0x5EE1, 0x0DEF, 0x5EE1, 0xF555, 0x8557,
+    0x4FF6, 0xEFEB, 0x7D78, 0xEBDD, 0xEBBD, 0xE061, 0x5555, 0xA0AA, 0x2A50, 0x5555, 0xA3AA, 0x2A50,
+    0x5555, 0x85AA, 0x5675, 0xAAAA, 0x0A55, 0x5505, 0x6AB5, 0x0A55, 0xFD54, 0x550D, 0x5A55, 0x0555,
+    0x553D, 0x55AB, 0x5550, 0x5515, 0x7655, 0x5550, 0x5555, 0x5055, 0xEB59, 0xB5AA, 0xAAAD, 0xDE53,
+    0x5555, 0xADBA, 0xAA50, 0xB52A, 0x5055, 0x55D0, 0x9F00, 0x0000, 0x0000, 0x00C6, 0x29F0, 0x5DF5,
+    0x0000, 0x0000, 0x0000, 0x00C0, 0x0200, 0xFF28, 0x810B, 0xFEF4, 0x9F31, 0x658C, 0x630C, 0x0000,
+    0xC075, 0x685C, 0x87E6, 0x8997, 0xBA38, 0x897D, 0xBA98, 0x5CCB, 0xD8C7, 0xB87D, 0xD5EC, 0x110E,
+    0x36F0, 0x1800, 0xA013, 0xEF09, 0x7EF4, 0x5BA5, 0x4E4D, 0x8266, 0x896A, 0x1B4D, 0xA26A, 0x8B26,
+    0x31B1, 0xA026, 0x492C, 0x6092, 0x08D0, 0x57F2, 0x14A0, 0x2600, 0xB4CA, 0xEF37, 0x0881, 0x387D,
+    0x2F68, 0x0802, 0x0000, 0x0000, 0x0000, 0x004A, 0x0000, 0x0305, 0x209C, 0x7A60, 0x908C, 0x1600,
+    0xCAA5, 0x718A, 0xF09E, 0xF686, 0x50B6, 0xC80B, 0xC0CA, 0xF648, 0x9C25, 0x1523, 0x00EC, 0xD8F3,
+    0xF4FE, 0x9556, 0x0840, 0x8C35, 0x356E, 0x40BB, 0xC200, 0x002C, 0x01AE, 0xDC2A, 0xBA00, 0x87EB,
+    0x955E, 0x3500, 0xF0BD, 0xE0FB, 0x9936, 0xA27F, 0x5B59, 0x7E53, 0x38AE, 0x9FDF, 0x27BE, 0x672B,
+    0x4EB6, 0xC4D1, 0xF916, 0x71EE, 0x2E0D, 0xDBF5, 0xEC82, 0x2B0A, 0x2994, 0x409A, 0xA039, 0x88A6,
+    0xB3F0, 0x24D1, 0xF3F5, 0x5C48, 0x122E, 0x9F43, 0x2609, 0x8A50, 0x89E4, 0xB010, 0x901C, 0x0100,
+    0xC1C0, 0x946D, 0x296E, 0xD9C6, 0xB22D, 0xC31B, 0xF7E8, 0xCECC, 0xEA27, 0xF9A7, 0xD0CA, 0xB21D,
+    0xCB75, 0x6CD7, 0xF6BF, 0x8374, 0xE759, 0xFB12, 0x9FD9, 0xC4B7, 0xA5ED, 0x938A, 0xE75B, 0xDC68,
+    0x25D0, 0xB765, 0xBE96, 0x2511, 0x46B7, 0xD25C, 0xDA97, 0x4B25, 0x4942, 0xF16D, 0xE4E2, 0x5822,
+    0xCA92, 0xB6CC, 0x4D12, 0x8DBE, 0x852D, 0x121C, 0x00C0, 0x41CC, 0x77D3, 0x0A27, 0xF57E, 0x7FAF,
+    0xA080, 0xDFB7, 0xA54D, 0x7C4B, 0x5AC4, 0x927D, 0xFCBA, 0xA2FB, 0x0703, 0x4685, 0xEA37, 0xCA4D,
+    0x1CE3, 0x912A, 0xBAD2, 0xF6AA, 0xB467, 0x2948, 0x2539, 0x7225, 0x8E31, 0xC295, 0x441A, 0x4B80,
+    0x2F39, 0x0925, 0xB184, 0x2BF1, 0x4400, 0x3009, 0x4030, 0x6368, 0xFFED, 0xFE38, 0x0C8C, 0xE354,
+    0xDBA7, 0xF8AE, 0xA921, 0xDCD5, 0xD43C, 0x7A08, 0xC6D1, 0x2407, 0x83A0, 0xE000, 0x0074, 0xBF47,
+    0xF3FC, 0xA9D0, 0x21A8, 0xB34D, 0xDAC7, 0xCA91, 0xC513, 0xA121, 0x8CA0, 0xDAAA, 0xC75B, 0xA804,
+    0x4B0C, 0x64C8, 0x84CF, 0x1680, 0x2B64, 0x3889, 0x0002, 0x3800, 0xD0F5, 0xBF7F, 0xBF24, 0x0000,
+    0x0008, 0x295B, 0x0FCD, 0x8713, 0x4AD7, 0x2180, 0xC101, 0x1009, 0x7D22, 0xA879, 0x53C0, 0x14D2,
+    0x610C, 0x90CD, 0x1594, 0x8A9E, 0x2129, 0x95C0, 0x3516, 0xF50D, 0x83A9, 0x400A, 0xB726, 0xEA8C,
+    0x0094, 0x85FA, 0xF456, 0x976F, 0xF9B4, 0xAA5A, 0x7481, 0xEEDD, 0x00A0, 0x6755, 0x8D76, 0x532B,
+    0xDEBA, 0x5975, 0x70D7, 0x667C, 0xDDEA, 0x5B8B, 0xCD98, 0xE330, 0x0655, 0x7D66, 0x2FF0, 0x9BAB,
+    0xF6F1, 0xEF3D, 0x86A6, 0x3228, 0x5277, 0xF410, 0x08A1, 0xD61A, 0x9919, 0xAC82, 0x54AA, 0xE953,
+    0x3DEE, 0x82D0, 0xA95E, 0x9C91, 0xBDF7, 0x5E7C, 0x39A3, 0x9F90, 0xA993, 0x5AA3, 0x87B8, 0x9D55,
+    0xCBE3, 0x7572, 0x7A2C, 0xDF19, 0x722A, 0xE419, 0x4551, 0xA4C3, 0xD875, 0x46C0, 0xD945, 0xB8A1,
+    0x72B2, 0x3273, 0x826B, 0xB466, 0xC63D, 0xFBCD, 0x9EC2, 0x4C31, 0x8A50, 0xA38B, 0x919B, 0x511D,
+    0xEF02, 0x20FD, 0xAD05, 0x4D16, 0x1CBD, 0xE852, 0x7FF5, 0xA686, 0x275A, 0x3F7E, 0x6D77, 0x77EF,
+    0xFE7F, 0xFFF8, 0x7DD7, 0xF79F, 0xD4C7, 0x1440, 0x9377, 0x445D, 0xC813, 0xCA9B, 0x3B36, 0x04A2,
+    0x6D4D, 0x9B18, 0x9345, 0x0573, 0x1B7D, 0xA7AA, 0xA20E, 0x8F04, 0x0084, 0xA003, 0x43A4, 0x1B8D,
+    0xF387, 0x04AC, 0x1CB0, 0x9273, 0x5843, 0x51AA, 0x9B51, 0xA1A9, 0xA4D0, 0x0407, 0x21E4, 0x9E05,
+    0x4A7B, 0x07D5, 0x1813, 0xEA1B, 0xA09E, 0x58BB, 0x5811, 0xAD3A, 0x15CB, 0x6EC4, 0xE005, 0xD520,
+    0xAA21, 0x1F6E, 0xDCE2, 0x79C4, 0x90C5, 0x5235, 0xB33C, 0x46BF, 0xA511, 0xA439, 0x4212, 0x8131,
+    0xF6CD, 0x9C37, 0x3C9E, 0xD6CF, 0x735B, 0x0CF6, 0xF5A1, 0xFB14, 0x5E9D, 0x38E7, 0x2408, 0x41CC,
+    0x9743, 0x8ADA, 0xFE07, 0x54A6, 0x33ED, 0x684D, 0xF668, 0x2864, 0x1D0F, 0xC00F, 0xD076, 0x6DD9,
+    0xF9DB, 0xDD06, 0x331F, 0xF33A, 0xF972, 0x164E, 0x1FF6, 0x1EEE, 0xF5FD, 0xEFD7, 0xB97D, 0xC4B3,
+    0x009C, 0xB9B3, 0xEE91, 0xA36B, 0x7DAD, 0xA77F, 0xF541, 0x38E0, 0x4ED0, 0x9E2D, 0x0D80, 0x4EF2,
+    0x15C8, 0x3C8D, 0x1DF9, 0x4EB7, 0xEDEE, 0xCAE5, 0xA012, 0x103D, 0x8CC0, 0xE67C, 0x2C01, 0x446B,
+    0x75EB, 0xDCE4, 0x8858, 0xBAE6, 0x7AB9, 0x14CC, 0xF465, 0xDEB5, 0xF13E, 0x809D, 0xC10A, 0x6586,
+    0x9792, 0x20E0, 0xF770, 0xAB77, 0x3DFE, 0xFA53, 0xF5D5, 0xAAF7, 0xE08A, 0xDC03, 0xD029, 0xA25D,
+    0x1CE4, 0x0E6C, 0x9505, 0xCA5C, 0x8032, 0x1B22, 0x0755, 0x30E0, 0x74E8, 0xD786, 0xECE0, 0xCB30,
+    0xC6C2, 0xC764, 0x753E, 0x4EF9, 0x37E4, 0xDD06, 0x6110, 0x0054, 0x27A5, 0xC67A, 0x88BE, 0xFAEA,
+    0x6395, 0xE090, 0x035A, 0x31A5, 0xD70A, 0x1278, 0xF45F, 0x97F0, 0x247A, 0xE628, 0x3F66, 0x8B97,
+    0xEBD5, 0x6583, 0xD329, 0x88C1, 0x0D16, 0xA636, 0x70FB, 0xD000, 0x02EE, 0xF323, 0x4096, 0x459D,
+    0x2407, 0xA7AA, 0x6AFF, 0xA7EB, 0x7DDF, 0x1B84, 0x0169, 0x1082, 0x6934, 0x0F5D, 0x1E3D, 0x6C2D,
+    0xA39D, 0x2483, 0x20C1, 0x03B0, 0xAECE, 0x7AB0, 0x1C5F, 0x02A8, 0xE7ED, 0xF47D, 0x52DE, 0x4B4B,
+    0x6102, 0xC8C7, 0xD653, 0x7CBC, 0x7D64, 0x1079, 0xCE63, 0x933D, 0x9B73, 0x2904, 0x08CE, 0x0F9B,
+    0x9C86, 0x8644, 0xB89A, 0x2CFE, 0x75FF, 0x0F79, 0xD784, 0xF43B, 0xA220, 0x273C, 0xCC14, 0xB6E3,
+    0x063B, 0xAE2F, 0x3E61, 0xF342, 0x073B, 0x79EB, 0x3E57, 0xBF26, 0xED18, 0x8037, 0x0304, 0x701E,
+    0x6CBF, 0x610C, 0xCBE1, 0x9397, 0xD1AE, 0x6246, 0xB2BF, 0x6731, 0x4507, 0x1406, 0x4E0A, 0x0268,
+    0xED30, 0x6417, 0x0304, 0x58D6, 0x3BEB, 0xE259, 0x9CF2, 0xD787, 0x261B, 0xEEDB, 0x0C84, 0x45BE,
+    0x72FE, 0x0FB1, 0x2364, 0x7FF4, 0x958E, 0x3EDB, 0x48E1, 0x4170, 0x060C, 0x435A, 0xEBF8, 0x9D91,
+    0x4D1C, 0x71CD, 0x7D46, 0x38BE, 0x7C82, 0x74C1, 0x01E6, 0x9F16, 0x9CF5, 0xB3E9, 0x74EF, 0x139C,
+    0xF573, 0xE860, 0x2774, 0xD6CF, 0xA103, 0xEE47, 0x593F, 0x870E, 0x467B, 0x6F9E, 0x6789, 0xC214,
+    0x0317, 0x820B, 0xAD8D, 0xEDD8, 0x00E3, 0x52D9, 0x3E24, 0x0000, 0xC04E, 0x0100, 0x0090, 0xFDBE,
+    0xF6FA, 0x8D80, 0x0200, 0x0000, 0x0000, 0x80C1, 0x8A9B, 0x2902, 0x118C, 0x97B0, 0xA58B, 0x18BF,
+    0xBA6F, 0x3F02, 0x52BB, 0x7A74, 0xDE22, 0x270A, 0x0340, 0xFA47, 0x11A8, 0x90C6, 0x18C7, 0x35B4,
+    0x8747, 0x3567, 0x0600, 0xF883, 0x0CA0, 0x7A1A, 0x7767, 0x147B, 0x2E5F, 0xF40A, 0x405D, 0x1EE5,
+    0x61B7, 0xCEAF, 0x2175, 0x42B9, 0x9CFB, 0x0CF5, 0x3C8E, 0x76D2, 0x4B79, 0x0F86, 0x19A8, 0x888E,
+    0x2674, 0x910D, 0xA7E2, 0xDBD0, 0xCE41, 0x3E1F, 0x403C, 0x72C6, 0x313E, 0xDD27, 0xFF2D, 0x60BC,
+    0x0700, 0xFE7F, 0x1B00, 0x0000, 0x0000, 0x0000, 0x9F31, 0x568C, 0x630C, 0x1DB1, 0x111B, 0xD447,
+    0x65D3, 0x5746, 0xE769, 0x7598, 0x7C67, 0x5878, 0x7869, 0x0031, 0xCB9F, 0xECB8, 0x89E3, 0x1DE3,
+    0x0C66, 0x2709, 0x3100, 0xFF11, 0x00A0, 0xF321, 0x0A7E, 0x2409, 0x49A2, 0xCF13, 0x15B5, 0x6DA2,
+    0x5DAB, 0x1ABB, 0x5A6D, 0x825D, 0x35A0, 0x6D5B, 0x0DC4, 0xB6AD, 0x4092, 0xB606, 0x2056, 0x0390,
+    0x68C2, 0xEF37, 0x3E20, 0x56DF, 0x8B89, 0x2000, 0x0000, 0x0000, 0xB469, 0x92C0, 0x0200, 0x5004,
+    0x7227, 0xE9B4, 0x32CA, 0xCFCB, 0x6239, 0xF500, 0x3067, 0xE441, 0x0054, 0x7420, 0x756B, 0x6B00,
+    0x0DC9, 0x3106, 0x90E0, 0xBC00, 0x400A, 0xE3B9, 0xE71B, 0xE0F8, 0x95FE, 0x4E32, 0xE2F6, 0xDC44,
+    0xF56F, 0x7078, 0xB311, 0x99FE, 0x8C69, 0x6EDE, 0x7199, 0x2EFD, 0x26F5, 0x0579, 0x0000, 0xE8F8,
+    0xD3B1, 0x7426, 0x4BC5, 0x463E, 0x6A37, 0x2A3E, 0xC2A7, 0xE3BC, 0x9429, 0x131C, 0x6414, 0xF71C,
+    0x9732, 0x6152, 0xE3CD, 0xFEE7, 0x7D57, 0xACA2, 0xB5B7, 0x6F55, 0xC6BC, 0xE70B, 0x55CB, 0xAFB3,
+    0x9235, 0xB932, 0xDD63, 0xAADA, 0x3A7B, 0xA934, 0x7DB4, 0xA45E, 0xDF95, 0x31FB, 0x72EA, 0x0B4B,
+    0xE950, 0x6878, 0xBE17, 0x4AFF, 0x5E41, 0x9836, 0xA6B7, 0x1157, 0x91F1, 0x7899, 0xA632, 0x425B,
+    0x57FB, 0x1B31, 0x8E1B, 0x3BE9, 0xE23A, 0x7801, 0x00C0, 0x1C2A, 0x2B31, 0x62DD, 0xF275, 0x8092,
+    0x8C63, 0x8C13, 0xB12A, 0x5AE9, 0xF9A5, 0x5CAA, 0x9932, 0xDE3D, 0xBDA9, 0xD011, 0x23BD, 0x2696,
+    0xFDFB, 0xCC4F, 0x8993, 0xCAA5, 0xBE97, 0x91FE, 0xD293, 0x8E9C, 0xB36B, 0xA736, 0xC278, 0xD1DB,
+    0x7853, 0x70F5, 0x6A96, 0x5D1C, 0x2D19, 0x97DA, 0xF4DA, 0x920F, 0x00C0, 0xF451, 0x8CDA, 0xE80F,
+    0x2326, 0x8F4B, 0xCB58, 0x9251, 0xA723, 0x750E, 0x65D2, 0x9A7E, 0xD679, 0xCEF5, 0x68B4, 0x657D,
+    0x75CF, 0x2E6D, 0x8479, 0x8FF7, 0x9E37, 0x07E5, 0xD5F6, 0x4766, 0x6EF7, 0x7C7E, 0x8A11, 0x75E3,
+    0xFA3E, 0xF102, 0x7DCB, 0xDC46, 0xC8AB, 0xA602, 0xA01E, 0x2BD2, 0x4B1B, 0xE9E4, 0x4083, 0x635C,
+    0xB7C5, 0xBD27, 0x8449, 0x153C, 0xEEBB, 0x1D25, 0x9907, 0xC284, 0xB273, 0xE512, 0xE7D8, 0x3DAE,
+    0x6477, 0x6734, 0xD151, 0x3DA4, 0xF318, 0xA729, 0x341E, 0x3523, 0x973D, 0x87B7, 0x660C, 0x35BC,
+    0x73F7, 0xA945, 0x9DFA, 0xE898, 0xDD8B, 0x815B, 0x5935, 0x3AFC, 0x6FE8, 0xAE6A, 0x0911, 0x393B,
+    0x0700, 0x0880, 0xFCDF, 0x7F5F, 0x0178, 0x91A3, 0x478F, 0x0E00, 0x004C, 0x3094, 0x7A81, 0x1917,
+    0x2EE3, 0x0D38, 0x30CB, 0x2DE8, 0x5C64, 0xF881, 0x7D1E, 0x6187, 0xFE3A, 0x8FA6, 0xB9D1, 0x1BB1,
+    0x4551, 0x8338, 0x9008, 0x6A37, 0x5D21, 0xB0BF, 0x32F6, 0x0ED5, 0x0489, 0xCEC8, 0xB603, 0xF562,
+    0x0400, 0xA008, 0xE0A4, 0x8A3F, 0xDCC3, 0x2930, 0xF8E4, 0x6960, 0x9413, 0x1847, 0xE054, 0xC3AE,
+    0xD9B3, 0xD935, 0x7B76, 0xB4DA, 0x023E, 0x335D, 0x391D, 0x7367, 0x5865, 0xCD3E, 0x7EBC, 0xDAF5,
+    0x3AE1, 0xAD85, 0xEF6C, 0xEF23, 0x6CF8, 0xA34F, 0xD60A, 0x7BEF, 0x0D83, 0x9B26, 0xC586, 0x93E3,
+    0x7139, 0xA5AF, 0xD097, 0xA595, 0x93E9, 0xCC56, 0x68BB, 0x822C, 0xF9B2, 0x292C, 0xAABB, 0xEB1D,
+    0x0270, 0xD97A, 0x4E20, 0x4E56, 0x9F33, 0x6F81, 0x2B1D, 0x715A, 0x54BB, 0x0A78, 0x014F, 0x59CD,
+    0x0ADC, 0xABB6, 0xE803, 0x50DB, 0xFDEF, 0xAFEF, 0xAE6F, 0xED3E, 0xB58E, 0x9381, 0x2780, 0x8351,
+    0x2789, 0x03C4, 0x67F0, 0x058D, 0xFE76, 0x79E2, 0xB611, 0x9A4E, 0x631C, 0xFBF2, 0x74B5, 0xC31F,
+    0x752F, 0x2E86, 0x8344, 0xF8B2, 0xE5C4, 0x0945, 0x52C1, 0x9D9B, 0x50A1, 0x8234, 0x09B6, 0xF06C,
+    0x1E05, 0x1C7E, 0xAD1D, 0xEFC1, 0xF03E, 0x7336, 0xB92D, 0xCE5A, 0xFD2C, 0x94B6, 0xE5CD, 0x1ACB,
+    0x6D7A, 0x3D38, 0xC16A, 0xA5C1, 0xF365, 0xDF2C, 0x8E9A, 0xBD01, 0xFC73, 0xABBE, 0x040E, 0x0068,
+    0xD653, 0x0F08, 0x5C79, 0x65AB, 0x3753, 0x5001, 0x428E, 0x4EEC, 0xA0E0, 0x523D, 0x29E8, 0x2002,
+    0xC0C3, 0x5FDF, 0xC544, 0xBD04, 0x644C, 0xE5C3, 0xCEDF, 0xCBB9, 0x0BE6, 0x600E, 0x46D4, 0x7A4F,
+    0x0EB6, 0x0307, 0x6DA7, 0xB97D, 0x0D37, 0x7DE1, 0x7E9C, 0x1D16, 0x710D, 0x61C8, 0x8460, 0xD180,
+    0x64A1, 0x4038, 0xAD54, 0x5AE5, 0xE122, 0xC0C6, 0x9152, 0xE980, 0x9938, 0x5522, 0x6639, 0x3A29,
+    0x330E, 0xB82D, 0x07FD, 0x0C82, 0xC793, 0xA874, 0x2F2F, 0xCADA, 0x8B1F, 0x9E4B, 0x3855, 0x9D11,
+    0xFA14, 0x5285, 0x65B3, 0xD943, 0x4282, 0x3091, 0x46C7, 0x1928, 0x07F3, 0x0CD1, 0x6275, 0x0B2D,
+    0x5F78, 0x491B, 0x047A, 0x46DC, 0x5631, 0x28F3, 0x9121, 0x8E22, 0xA1BA, 0xD02E, 0x4E7D, 0xAA4F,
+    0x75EA, 0x7835, 0x75A7, 0x0100, 0x04F1, 0x21F2, 0x8F15, 0x7511, 0x10CE, 0x1CF4, 0xE564, 0x7EA5,
+    0x6B93, 0xB038, 0x350E, 0x801F, 0x3073, 0xA053, 0xA5C3, 0x8071, 0x980F, 0x1523, 0x3045, 0x99C2,
+    0xC6FC, 0xB91F, 0x7747, 0xE9E6, 0x76EA, 0x27BC, 0x8309, 0x39DA, 0x001D, 0x5CA9, 0x0282, 0xA956,
+    0xE385, 0xDA19, 0x0F2E, 0x0F47, 0x7D21, 0x8D40, 0xF809, 0xB821, 0x28A0, 0x3FEA, 0xB2D4, 0xD600,
+    0x8274, 0xDBA8, 0xBBA8, 0xE7FC, 0x55F3, 0xD99A, 0x1EE2, 0x209F, 0xD8D3, 0x3460, 0xE220, 0x061E,
+    0x1091, 0x70E4, 0xEF87, 0x9BBF, 0x0AC3, 0xD098, 0xD6F7, 0x3B18, 0x849B, 0x948E, 0x9975, 0xD87A,
+    0x6F34, 0x2739, 0x85C0, 0x810D, 0x4822, 0xBC22, 0xABB8, 0x90B9, 0x65F9, 0xEB84, 0x3356, 0xD58F,
+    0x83FB, 0x5F62, 0x522C, 0x00FB, 0x2767, 0x81B8, 0x9A0D, 0xFFCC, 0xBD00, 0xCAED, 0x43F0, 0x9006,
+    0x29A0, 0x1D9C, 0x2ED4, 0x7971, 0xCDFB, 0x6FEA, 0xC8C9, 0x11E7, 0xBB7D, 0x6FA2, 0xEC70, 0x2728,
+    0x070B, 0x15E2, 0x3493, 0x4AB2, 0x40A2, 0x0561, 0x1010, 0xDC94, 0x4A6C, 0xE4E0, 0xB1EA, 0x88E0,
+    0xF58F, 0xBA3E, 0xC303, 0x57FB, 0x5536, 0x0330, 0x7705, 0xA9E6, 0x9AE3, 0xDA62, 0x8793, 0x80E7,
+    0x3531, 0xE8C8, 0xD7CE, 0x6618, 0x8311, 0xD163, 0x85C1, 0x814C, 0x2E9F, 0x4611, 0x18A0, 0x5DBB,
+    0xC1CE, 0xE622, 0x8150, 0x0950, 0x7A64, 0xADBC, 0xD185, 0xBF14, 0x6817, 0xA47F, 0x1CDF, 0x6200,
+    0x2433, 0xF7BA, 0x38FE, 0x537F, 0x96B3, 0xE400, 0x211C, 0xA004, 0x381F, 0x6168, 0x7A02, 0x44D4,
+    0xE2C5, 0xC35B, 0xAD04, 0x0EB5, 0x98A6, 0xE5F3, 0x3CB5, 0x6FD5, 0x789F, 0x542C, 0x5028, 0xC71F,
+    0xB0C1, 0x6903, 0x6F27, 0x948C, 0x1C4E, 0x4D5B, 0xCA77, 0xBB93, 0x010D, 0x034A, 0x84F0, 0x9F4B,
+    0x0601, 0x8218, 0x0335, 0x733C, 0x9F1F, 0x4302, 0x0040, 0x42A2, 0xD470, 0xD292, 0xC815, 0x3601,
+    0x00CE, 0x433F, 0x1CE9, 0x5247, 0xCB5C, 0x6610, 0xBC5B, 0x0283, 0x0B1C, 0x5301, 0x0E91, 0xEF88,
+    0x4790, 0x547D, 0xDCEC, 0xF132, 0x9CD2, 0xABAA, 0x1AAF, 0x8F8A, 0xB014, 0x7055, 0x4434, 0x03F0,
+    0x9CE0, 0x2457, 0x061F, 0x4E5C, 0x2760, 0x919C, 0x6EE8, 0xE81D, 0x3435, 0x1C9C, 0x03C2, 0x4940,
+    0xE829, 0x1204, 0x760E, 0x2E09, 0x886D, 0x3A55, 0xDF6B, 0x030C, 0x4355, 0xFBB1, 0xE23E, 0xCFF4,
+    0x2209, 0x4240, 0x721E, 0x6461, 0x0F47, 0x1A56, 0xF80B, 0x360B, 0x45F2, 0x85BB, 0xAE77, 0x30DD,
+    0xFC1C, 0xF49F, 0x344F, 0x4CE6, 0x9093, 0x7448, 0xE8C6, 0xF0A5, 0x1CC0, 0x9274, 0xAF7D, 0x75F0,
+    0xE19B, 0x00C4, 0x5296, 0x0740, 0xB795, 0x441C, 0x5A4F, 0xE29E, 0x871A, 0x437F, 0x576E, 0xCFD1,
+    0x00E1, 0x1BA5, 0x0F29, 0xDC39, 0x4538, 0x8FA5, 0x65B8, 0x1122, 0xD18D, 0xD2FA, 0x31ED, 0x3CEE,
+    0xAA00, 0x69D7, 0x9375, 0x4014, 0x1435, 0x5361, 0xA58F, 0xA07C, 0xEF5D, 0x0000, 0x20B3, 0xC737,
+    0x118E, 0x635E, 0xAE1F, 0x7EC7, 0xDCA7, 0x0BA1, 0x00AA, 0x20B8, 0xD71D, 0x5F15, 0x0078, 0x25FF,
+    0xFCFB, 0x6F79, 0xAD0A, 0xE156, 0xC843, 0xE2DC, 0x1993, 0x8CB0, 0x1A13, 0x258C, 0x165E, 0x7AFB,
+    0x9E0B, 0x72FD, 0xF648, 0xDEAE, 0x07FE, 0x9301, 0x0000, 0xCC3F, 0x8660, 0xDE8B, 0xDFDC, 0x6368,
+    0x3D67, 0x5D4D, 0x7AD4, 0x1E2F, 0x6398, 0xFE35, 0xCD74, 0xC027, 0x99AE, 0x2814, 0x5AB9, 0x3053,
+    0x5C4B, 0x309E, 0x6AC5, 0x50BC, 0xB80C, 0x4F16, 0x0000, 0x0000, 0x6083, 0xF02B, 0x5778, 0x2EDD,
+    0xF828, 0x300C, 0x0100, 0x0000, 0x0000, 0x00E0, 0x3587, 0x2650, 0x4263, 0xE64E, 0x844B, 0x043B,
+    0xC926, 0x7F1C, 0xCBA0, 0x06E5, 0x37F1, 0x59AF, 0xCE21, 0x4EBF, 0x8231, 0x45D6, 0x8003, 0x6E00,
+    0x603D, 0x1BDA, 0x205B, 0xEC12, 0x9EC8, 0x3DF1, 0x78B1, 0x81E7, 0x3968, 0x3AEC, 0x7D2E, 0x9B3D,
+    0xA066, 0x0E00, 0x12E0, 0x05C9, 0x63E5, 0x0726, 0x87D2, 0x16E9, 0x01EA, 0xDD8D, 0xC9E0, 0x4B0E,
+    0x33CC, 0x4C1F, 0x2739, 0x960B, 0xDCE3, 0x6091, 0x1032, 0x6016, 0x9DAC, 0x53AA, 0xBA2F, 0x5040,
+    0xB9A7, 0x3638, 0x7364, 0x5D22, 0xA90C, 0x6887, 0x8B19, 0x29BC, 0x348E, 0x19BA, 0x58D5, 0xFA48,
+    0xEA56, 0xCFB4, 0x660C, 0x0901, 0x92E5, 0x01B8, 0x6F66, 0xE1B6, 0x4164, 0x134F, 0x99EE, 0xD4BC,
+    0xE409, 0x3A20, 0xF3DC, 0x9B15, 0x7BDB, 0x6257, 0xF81A, 0x88DE, 0xD389, 0x8FF8, 0x0DC8, 0xB1DF,
+    0xDC40, 0x6A1D, 0x9411, 0x78EC, 0x39EC, 0x1403, 0x31CC, 0x870C, 0xCD59, 0x6240, 0xF31C, 0x473E,
+    0x3106, 0x79F9, 0xE4B4, 0x5FFA, 0x5785, 0x8A93, 0x3A20, 0xBCE1, 0xA861, 0x1266, 0xCB01, 0x0400,
+    0x91E4, 0x50E5, 0x55B3, 0xFA18, 0x60F4, 0x76B4, 0xF828, 0x2E2F, 0xC1FB, 0x4E33, 0x1428, 0x8F83,
+    0x43C0, 0xC011, 0xC20F, 0x855B, 0x7DF5, 0x0207, 0x0A12, 0x2AAB, 0xE638, 0x330D, 0x2C68, 0xFBB9,
+    0x3433, 0x41DF, 0xD993, 0x733D, 0x194B, 0x8E0A, 0xDE73, 0xC0B8, 0x3100, 0x949D, 0xBD27, 0x0EE0,
+    0x729C, 0x7E0F, 0xA607, 0x3ED7, 0x50BF, 0x8E80, 0x59B3, 0x3AEE, 0x9FAF, 0x7379, 0x925B, 0x15F7,
+    0x92EF, 0x1272, 0x0A1E, 0x00BD, 0x7E1B, 0x0000, 0x0000, 0x0000
+};
+
+static u32 ForceRateDiv;
+
+static u32 sysopen = 0;
+static u32 sndopen = 0;
+static u32 numopensounds = 0;
+static u32 cb_bink_IO = 0;
+static u32 cb_bink_sound = 0;
+static u32 ForceRate = 0xFFFFFFFF;
+static u32 IOBufferSize = 0xFFFFFFFF;
+static u32 Simulate = 0xFFFFFFFF;
+static u32 TotTracks = 1;
+static u32 UserOpen = 0;
+
+void bpopmalloc(HBINK bnk, u32 tmpArg)
+{
+    u32 tmpReg;
+
+    tmpReg = popmalloctotal();
+    bnk->totalmem = bnk->totalmem + tmpReg + tmpArg;
+    popmalloc();
+}
+
+void BinkSetError(const char* err)
+{
+    strcpy(binkerr, err);
+}
+
+char* BinkGetError(void)
+{
+    return binkerr;
+}
+
+// TODO: Fix Function
+// I hate nested if's
+s32 BinkSetSoundSystem(BINKSNDSYSOPEN open, u32 param)
+{
+    BINKSNDSYSOPEN* pcVar1;
+    s32 iVar2;
+
+    if (open != NULL)
+    {
+        if (sysopen == NULL)
+        {
+            sysopen = open;
+        }
+        pcVar1 = sysopen;
+        if ((sysopen == open) || (pcVar1 = open, numopensounds != 0))
+        {
+            sysopen = pcVar1;
+            iVar2 = (param);
+            if (iVar2 != 0)
+            {
+                sndopen = iVar2;
+            }
+            if (sndopen != 0)
+            {
+                return 1;
+            }
+            return 0;
+        }
+    }
+    return 0;
+}
+
+// (undefined *param_1,undefined2 *param_2,uint param_3)
+void conv16to8()
+{
+}
+
+void checksound(u32 tmp)
+{
+}
+
+void inittimer(HBINK bnk)
+{
+    if (bnk->startsynctime == 0)
+    {
+        bnk->startsynctime = RADTimerRead();
+        bnk->startsyncframe = bnk->playedframes - 1;
+    }
+}
+
+void GotoFrame(HBINK bnk, u32 tmp)
+{
+    u32 uVar1;
+
+    if (tmp != 0)
+    {
+        tmp = tmp - 1;
+    }
+    bnk->bsnd = 0;
+    if (bnk->lastresynctime != 0)
+    {
+        checksound(bnk);
+    }
+    bnk->LastFrameNum = bnk->FrameNum;
+    if (tmp == 0)
+    {
+        if (bnk->soundon != 0)
+        {
+            BinkSetSoundOnOff(bnk, 0);
+            BinkSetSoundOnOff(bnk, 1);
+        }
+        bnk->startsynctime = 0;
+        bnk->bunp.patptr = 0; // had to change this, I assume the struct is correct
+    }
+    if (bnk->preloadptr != 0)
+    {
+        bnk->compframe = bnk->preloadptr + ((bnk->frameoffsets[tmp] & 0xfffffffe) -
+                                            ((*bnk->frameoffsets) & 0xfffffffe));
+    }
+    else
+    {
+        uVar1 = (bnk->frameoffsets[tmp] & 0xfffffffe) & 0xfffffffe;
+        (bnk->bio.ReadFrame)(&bnk->bio, tmp, uVar1, bnk->compframe,
+                             (*((bnk->frameoffsets + tmp) + 1) & 0xfffffffe) - uVar1);
+    }
+    if (bnk->lastresynctime != 0)
+    {
+        checksound(bnk);
+    }
+    bnk->FrameNum = tmp + 1;
+}
+
+void BinkSetFrameRate(u32 FRate, u32 FRateDiv)
+{
+    ForceRate = FRate;
+    ForceRateDiv = FRateDiv;
+}
+
+void BinkSetIOSize(u32 iosize)
+{
+    IOBufferSize = iosize;
+}
+
+void BinkSetIO(BINKIOOPEN io)
+{
+    UserOpen = (u32)io;
+}
+
+void BinkSetSimulate(u32 sim)
+{
+    Simulate = sim;
+}
+
+void BinkSetSoundTrack(u32 total_tracks, u32* tracks)
+{
+    u32 i;
+    s32 iVar2;
+
+    if (8 < total_tracks)
+    {
+        total_tracks = 8;
+    }
+    i = 0;
+    TotTracks = total_tracks;
+    if (TotTracks == 0)
+    {
+        return;
+    }
+    for (i = 0; i < total_tracks; i++)
+    {
+        *(u32*)((s32)&TrackNums + iVar2) = *(u32*)(iVar2 + total_tracks);
+        iVar2 = iVar2 + 4;
+    }
+}
+
+void bink_suspend_io(HBINK bnk)
+{
+    RADCB_suspend_callback(cb_bink_IO, &bnk->Paused);
+}
+
+void bink_try_suspend_io(HBINK bnk)
+{
+    RADCB_try_to_suspend_callback(cb_bink_IO, &bnk->Paused);
+}
+
+void bink_resume_io(HBINK bnk)
+{
+    RADCB_resume_callback(cb_bink_IO, &bnk->Paused);
+}
+
+void bink_idle_on_io(HBINK bnk)
+{
+    RADCB_idle_on_callbacks();
+}
+
+u32 bink_get_priority_sound(s32 tmp, u32 tmp2)
+{
+    if (*(u32*)(tmp + -4) != tmp2)
+    {
+        return ~*(u32*)(tmp + -4);
+    }
+    return 0;
+}
+
+void bink_sound_callback(HBINK bnk, u32 tmp)
+{
+    if (bnk->lastresynctime != NULL)
+    {
+        checksound(&bnk->last_read_count);
+    }
+    bnk->last_time_almost_empty = tmp;
+}
+
+HBINK BinkOpen(const char PTR4* name, u32 flags)
+{
+}
+
+s32 BinkCopyToBuffer(HBINK bnk, void* dest, s32 destpitch, u32 destheight, u32 destx, u32 desty,
+                     u32 flags)
+{
+    BinkCopyToBufferRect(bnk, dest, destpitch, destheight, destx, desty, 0, 0, bnk->Width,
+                         bnk->Height, flags);
+}
+
+s32 BinkCopyToBufferRect(HBINK bnk, void* dest, s32 destpitch, u32 destheight, u32 destx, u32 desty,
+                         u32 srcx, u32 srcy, u32 srcw, u32 srch, u32 flags)
+{
+}
+
+s32 BinkDoFrame(HBINK bnk)
+{
+}
+
+void timeframe(HBINK bnk, u32 tmp)
+{
+    u32 tmpReg;
+
+    tmpReg = (bnk->startblittime);
+    if (tmpReg == 0)
+    {
+        return;
+    }
+    bnk->startblittime = 0;
+    bnk->timeblit = (bnk->timeblit) + (tmp - tmpReg);
+}
+
+void BinkNextFrame(HBINK bnk)
+{
+}
+
+u32 BinkGetKeyFrame(HBINK bnk, u32 frame, s32 flags)
+{
+}
+
+void BinkGoto(HBINK bnk, u32 frame, s32 flags)
+{
+}
+
+void BinkClose(HBINK bnk)
+{
+}
+
+// TODO:
+// Double check that the second are is supposed to be a u32
+void endframe(HBINK bnk, u32 tmp)
+{
+}
+
+s32 BinkWait(HBINK bnk)
+{
+}
+
+s32 BinkPause(HBINK bnk, s32 pause)
+{
+}
+
+void BinkGetSummary(HBINK bnk, BINKSUMMARY* sum)
+{
+}
+
+void BinkGetRealtime(HBINK bink, BINKREALTIME PTR4* run, u32 frames)
+{
+}
+
+// need to add in the proper args. should be like 4 of em
+// void smallestrect()
+// {
+// }
+
+// need to add in the proper args. should be like 5 of em
+// void trysplit()
+// {
+// }
+
+s32 BinkGetRects(HBINK bnk, u32 flags)
+{
+}
+
+void BinkService(HBINK bink)
+{
+    if ((bink->lastresynctime) != 0)
+    {
+        checksound(bink);
+    }
+}
+
+// TODO:
+// Double check that the second are is supposed to be a u32
+s32 idtoindex(HBINK bnk, u32 tmp)
+{
+}
+
+void BinkSetVolume(HBINK bnk, u32 trackid, s32 volume)
+{
+}
+
+void BinkSetMixBins(HBINK bnk, u32 trackid, u32 PTR4* mix_bins, u32 total)
+{
+}
+
+void BinkSetMixBinVolumes(HBINK bnk, u32 trackid, u32* vol_mix_bins, s32* volumes, u32 total)
+{
+}
+
+void BinkSetPan(HBINK bnk, u32 trackid, s32 pan)
+{
+}
+
+void* BinkLogoAddress()
+{
+    return LogoData;
+}
+
+u32 BinkGetTrackType(HBINK bnk, u32 trackindex)
+{
+    if (bnk != 0)
+    {
+        return *(u32*)(trackindex * 1 + (bnk->tracktypes));
+    }
+    return 0;
+}
+
+u32 BinkGetTrackMaxSize(HBINK bnk, u32 trackindex)
+{
+    if (bnk != 0)
+    {
+        return *(u32*)(trackindex * 1 + (bnk->tracksizes));
+    }
+    return 0;
+}
+
+u32 BinkGetTrackID(HBINK bnk, u32 trackindex)
+{
+    if (bnk != 0)
+    {
+        return *(u32*)(trackindex * 1 + (bnk->trackIDs));
+    }
+    return 0;
+}
+
+HBINKTRACK BinkOpenTrack(HBINK bnk, u32 trackindex)
+{
+}
+
+void BinkCloseTrack(HBINKTRACK bnkt)
+{
+    if (bnkt != 0)
+    {
+        if (bnkt->sndcomp != 0)
+        {
+            BinkAudioDecompressClose(bnkt->sndcomp);
+            bnkt->sndcomp = 0;
+        }
+        radfree(bnkt);
+    }
+}
+
+u32 BinkGetTrackData(HBINKTRACK bnkt, void* dest)
+{
+}
+
+s32 BinkSetVideoOnOff(HBINK bnk, s32 onoff)
+{
+    if (bnk != 0)
+    {
+        bnk->videoon = onoff;
+    }
+    return onoff;
+}
+
+s32 BinkSetSoundOnOff(HBINK bnk, s32 onoff)
+{
+}
diff --git a/src/bink/src/sdk/decode/expand.c b/src/bink/src/sdk/decode/expand.c
index e69de29bb..e56c5e5d0 100644
--- a/src/bink/src/sdk/decode/expand.c
+++ b/src/bink/src/sdk/decode/expand.c
@@ -0,0 +1,35 @@
+#include "bink.h"
+
+static const char huff4decode00[16] = "@ABCDEFGHIJKLMNO";
+static const char huff4decode01[32] =
+    "\20A\20R\20S\20T\20U\20V\20W\20X\20A\20Y\20Z\20[\20\\\20]\20^\20_";
+static const char huff4decode02[32] = " B!X T!\\ C!Z V!^ B!Y U!] C![ W!_";
+static const char huff4decode03[32] = " C1X E2\\ D1Z V2^ C1Y E2] D1[ W2_";
+static const char huff4decode04[32] = "0D2X1F3\\0E2Z1G3^0D2Y1F3]0E2[1G3_";
+static const char huff4decode05[32] = "0FBJ1HD\\0GCK1IE^0FBJ1HD]0GCK1IE_";
+static const char huff4decode06[32] = " EAI GC\\ FBZ HD^ EAI GC] FB[ HD_";
+static const char huff4decode07[64] =
+    "1S2h1U2l1T2j1f2n1S2i1U2m1T2k1g2o";
+static const char huff4decode08[64] =
+    "\20!\20R\20!\20h\20!\20d\20!\20l\20!\20S\20!\20j\20!\20f\20!\20n\20!\20R\20!\20i\20!\20e\20!\20m\20!\20S\20!\20k\20!\20g\20!\20o";
+static const char huff4decode09[64] =
+    "1TBh1VCl1UBj1WCn1TBi1VCm1UBk1WCo";
+static const char huff4decode10[64] =
+    " 2!U C!Y 2!W D!l 2!V C!j 2!X D!n 2!U C!Y 2!W D!m 2!V C!k 2!X D!o";
+static const char huff4decode11[64] =
+    "\20A\20U\20C\20Y\20B\20W\20D\20l\20A\20V\20C\20j\20B\20X\20D\20n\20A\20U\20C\20Y\20B\20W\20D\20m\20A\20V\20C\20k\20B\20X\20D\20o";
+static const char huff4decode12[64] =
+    " \"!S \"!h \"!U \"!l \"!T \"!j \"!f \"!n \"!S \"!i \"!U \"!m \"!T \"!k \"!g \"!o";
+static const char huff4decode13[128] =
+    "132d132x132f132|132e132z132g132~132d132y132f132}132e132{132g132";
+static const char huff4decode14[128] =
+    "132T132x132e132|132T132z132v132~132T132y132e132}132T132{132w132";
+static const char huff4decode15[128] =
+    " 2!4 3!e 2!4 3!i 2!4 3!g 2!4 3!| 2!4 3!f 2!4 3!z 2!4 3!h 2!4 3!~ 2!4 3!e 2!4 3!i 2!4 3!g 2!4 3!} 2!4 3!f 2!4 3!{ 2!4 3!h 2!4 3!";
+static const char huff4reads[16] = "\4\5\5\5\5\5\5\6\6\6\6\6\6\7\7\7";
+static const char mask2[64] =
+    "\0\0\0\0\377\0\0\0\0\377\0\0\377\377\0\0\0\0\377\0\377\0\377\0\0\377\377\0\377\377\377\0\0\0\0\377\377\0\0\377\0\377\0\377\377\377\0\377\0\0\377\377\377\0\377\377\0\377\377\377\377\377\377\377";
+static const char mask1[64] =
+    "\377\377\377\377\0\377\377\377\377\0\377\377\0\0\377\377\377\377\0\377\0\377\0\377\377\0\0\377\0\0\0\377\377\377\377\0\0\377\377\0\377\0\377\0\0\0\377\0\377\377\0\0\0\377\0\0\377\0\0\0\0\0\0\0";
+static const char mask4[16] = "\0\0\0\0\377\377\0\0\0\0\377\377\377\377\377\377";
+static const char mask3[16] = "\377\377\377\377\0\0\377\377\377\377\0\0\0\0\0\0";
diff --git a/src/bink/src/sdk/decode/ngc/binkngc.c b/src/bink/src/sdk/decode/ngc/binkngc.c
index e69de29bb..996e26ff4 100644
--- a/src/bink/src/sdk/decode/ngc/binkngc.c
+++ b/src/bink/src/sdk/decode/ngc/binkngc.c
@@ -0,0 +1,25 @@
+#include "binkngc.h"
+#include "dolphin/os/OSAlloc.h"
+
+u32 usermalloc = NULL;
+void* userfree = NULL;
+
+void radfree(void* ptr)
+{
+    u8* ptrU8 = (u8*)ptr;
+    u32* ptrU32 = (u32*)ptr;
+
+    void (*customFree)(void*);
+    if (ptr)
+    {
+        if ((ptrU8[-2]) == 3)
+        {
+            customFree = (void*)(ptrU32[-2]);
+            customFree(ptrU8 - ptrU8[-1]);
+        }
+        else
+        {
+            OSFreeToHeap((void*)__OSCurrHeap, ptrU8 - ptrU8[-1]);
+        }
+    }
+}
diff --git a/src/bink/src/sdk/popmal.c b/src/bink/src/sdk/popmal.c
index d3ce45f80..e380fc7b0 100644
--- a/src/bink/src/sdk/popmal.c
+++ b/src/bink/src/sdk/popmal.c
@@ -1,8 +1,22 @@
 #include "popmal.h"
 
 u32 pushtot = NULL;
+u32 pushcur = NULL;
+u32 pushptr = NULL;
+u32 pushamt = NULL;
+u32 cursize = 32;
+
+// TODO:
+// figure out what arg 1 should be. pretty confident arg 2 is correct
+void pushmalloc(BINKIO* io, HBINK bnk)
+{
+}
 
 u32 popmalloctotal()
 {
     return pushtot;
 }
+
+u32 popmalloc(HBINK bnk)
+{
+}
diff --git a/src/dolphin/include/dolphin/os/OSAlarm.h b/src/dolphin/include/dolphin/os/OSAlarm.h
index 7b4a266e2..844cfe89a 100644
--- a/src/dolphin/include/dolphin/os/OSAlarm.h
+++ b/src/dolphin/include/dolphin/os/OSAlarm.h
@@ -3,7 +3,7 @@
 
 #include <dolphin/os/OSContext.h>
 #include <dolphin/os/OSTime.h>
-#include <types.h>
+#include <dolphin/types.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -12,14 +12,15 @@ extern "C" {
 typedef struct OSAlarm OSAlarm;
 typedef void (*OSAlarmHandler)(OSAlarm* alarm, OSContext* context);
 
-struct OSAlarm {
-  OSAlarmHandler handler;
-  u32 tag;
-  OSTime fire;
-  OSAlarm* prev;
-  OSAlarm* next;
-  OSTime period;
-  OSTime start;
+struct OSAlarm
+{
+    OSAlarmHandler handler;
+    u32 tag;
+    OSTime fire;
+    OSAlarm* prev;
+    OSAlarm* next;
+    OSTime period;
+    OSTime start;
 };
 
 void OSInitAlarm(void);
diff --git a/src/dolphin/include/dolphin/os/OSContext.h b/src/dolphin/include/dolphin/os/OSContext.h
index fb024f8c5..b9b7ad8b2 100644
--- a/src/dolphin/include/dolphin/os/OSContext.h
+++ b/src/dolphin/include/dolphin/os/OSContext.h
@@ -1,7 +1,7 @@
 #ifndef _DOLPHIN_OSCONTEXT
 #define _DOLPHIN_OSCONTEXT
 
-#include <types.h>
+#include <dolphin/types.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -134,27 +134,28 @@ extern "C" {
 
 #define OS_CONTEXT_STATE_FPSAVED 0x01u
 
-typedef struct OSContext {
-  u32 gpr[32];
-  u32 cr;
-  u32 lr;
-  u32 ctr;
-  u32 xer;
+typedef struct OSContext
+{
+    u32 gpr[32];
+    u32 cr;
+    u32 lr;
+    u32 ctr;
+    u32 xer;
 
-  f64 fpr[32];
+    f64 fpr[32];
 
-  u32 fpscr_pad;
-  u32 fpscr;
+    u32 fpscr_pad;
+    u32 fpscr;
 
-  u32 srr0;
-  u32 srr1;
+    u32 srr0;
+    u32 srr1;
 
-  u16 mode;
-  u16 state;
+    u16 mode;
+    u16 state;
 
-  u32 gqr[8];
-  u32 psf_pad;
-  f64 psf[32];
+    u32 gqr[8];
+    u32 psf_pad;
+    f64 psf[32];
 
 } OSContext;
 
@@ -162,7 +163,7 @@ u32 OSSaveContext(OSContext* context);
 void OSClearContext(OSContext* context);
 OSContext* OSGetCurrentContext();
 void OSSetCurrentContext(OSContext* context);
-void OSFillFPUContext(OSContext *context);
+void OSFillFPUContext(OSContext* context);
 u32 OSGetStackPointer();
 
 #ifdef __cplusplus
diff --git a/tools/project.py b/tools/project.py
index f39593ff6..b33a4bc4e 100644
--- a/tools/project.py
+++ b/tools/project.py
@@ -1421,7 +1421,7 @@ def generate_objdiff_config(
         "Wii/1.3": "mwcc_43_172",
         "Wii/1.5": "mwcc_43_188",
         "Wii/1.6": "mwcc_43_202",
-        "Wii/1.7": "mwcc_43_213",
+        "ProDG/3.5": "mwcc_43_213",
     }
 
     def add_unit(