diff --git a/src/SB/Core/x/xMath3.cpp b/src/SB/Core/x/xMath3.cpp
index 849cf1fb6..3aed6c4d8 100644
--- a/src/SB/Core/x/xMath3.cpp
+++ b/src/SB/Core/x/xMath3.cpp
@@ -155,28 +155,128 @@ void xBoxFromCone(xBox& box, const xVec3& center, const xVec3& dir, F32 dist, F3
     xBoxUnion(box, box, temp);
 }
 
-void xMat4x3Rot(xMat4x3* m, const xVec3* a, F32 t, const xVec3* p)
+void xMat3x3Normalize(xMat3x3* o, const xMat3x3* m)
 {
-    xMat4x3 temp;
+    xVec3Normalize(&o->right, &m->right);
+    xVec3Normalize(&o->up, &m->up);
+    xVec3Normalize(&o->at, &m->at);
+}
 
-    xMat3x3RotC(m, a->x, a->y, a->z, t);
-    xVec3Copy(&m->pos, p);
-    xMat3x3Identity(&temp);
-    xVec3Inv(&temp.pos, p);
-    xMat4x3Mul(m, &temp, m);
+void xMat3x3GetEuler(const xMat3x3* m, xVec3* a)
+{
+    F32 yaw = -xasin(m->at.y);
+
+    F32 roll;
+    F32 pitch;
+
+    if (yaw < (PI / 2))
+    {
+        if (yaw > -(PI / 2))
+        {
+            pitch = xatan2(m->at.x, m->at.z);
+            roll = xatan2(m->right.y, m->up.y);
+        }
+        else
+        {
+            pitch = -xatan2(-m->up.x, m->right.x);
+            roll = 0.0f;
+        }
+    }
+    else
+    {
+        pitch = xatan2(-m->up.x, m->right.x);
+        roll = 0.0f;
+    }
+
+    a->x = pitch;
+    a->y = yaw;
+    a->z = roll;
 }
 
-/* xMat4x3Mul (xMat4x3 *, xMat4x3 const *, xMat4x3 const *) */
-void xMat4x3Mul(xMat4x3* o, const xMat4x3* a, const xMat4x3* b)
+void xMat4x3MoveLocalRight(xMat4x3* m, F32 mag)
 {
-    xVec3 sp8;
+    m->pos.x += m->right.x * mag;
+    m->pos.y += m->right.y * mag;
+    m->pos.z += m->right.z * mag;
+}
 
-    xMat4x3Toworld(&sp8, b, &a->pos);
-    xMat3x3Mul((xMat3x3*)o, (xMat3x3*)a, (xMat3x3*)b);
-    xVec3Copy(&o->pos, &sp8);
+void xMat4x3MoveLocalUp(xMat4x3* m, F32 mag)
+{
+    m->pos.x += m->up.x * mag;
+    m->pos.y += m->up.y * mag;
+    m->pos.z += m->up.z * mag;
+}
+
+void xMat4x3MoveLocalAt(xMat4x3* m, F32 mag)
+{
+    m->pos.x += m->at.x * mag;
+    m->pos.y += m->at.y * mag;
+    m->pos.z += m->at.z * mag;
+}
+
+F32 xMat3x3LookVec(xMat3x3* m, const xVec3* at)
+{
+    F32 temp_f2;
+    F32 temp_f31;
+    xVec3* temp_r3;
+
+    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)
+    {
+        m->right.x = 1.0f;
+        m->right.y = 0.0f;
+        m->right.z = 0.0f;
+        m->up.x = 0.0f;
+        m->up.y = 0.0f;
+        m->up.z = 1.0f;
+        m->at.x = 0.0f;
+        m->at.y = -1.0f;
+        m->at.z = 0.0f;
+        return temp_f31;
+    }
+    if ((F32)__fabs(1.0f + m->at.y) < 0.00001f)
+    {
+        m->right.x = -1.0f;
+        m->right.y = 0.0f;
+        m->right.z = 0.0f;
+        m->up.x = 0.0f;
+        m->up.y = 0.0f;
+        m->up.z = -1.0f;
+        m->at.x = 0.0f;
+        m->at.y = 1.0f;
+        m->at.z = 0.0f;
+        return temp_f31;
+    }
+    if ((FABS(at->z) < 0.00001f) && (FABS(at->x) < 0.00001f))
+    {
+        m->right.x = 1.0f;
+        m->right.y = 0.0f;
+        m->right.z = 0.0f;
+        m->up.x = 0.0f;
+        m->up.y = 1.0f;
+        m->up.z = 0.0f;
+        m->at.x = 0.0f;
+        m->at.y = 0.0f;
+        m->at.z = 1.0f;
+        return 0.0f;
+    }
+    m->right.x = m->at.z;
+    m->right.y = 0.0f;
+    m->right.z = -m->at.x;
+    xVec3Normalize((xVec3*)m, (xVec3*)m);
+    xVec3Cross(&m->up, &m->at, (xVec3*)m);
+    xVec3Cross((xVec3*)m, &m->up, &m->at);
+    m->flags = 0;
+    return temp_f31;
+}
+
+void xMat3x3Euler(xMat3x3* m, const xVec3* ypr)
+{
+    xMat3x3Euler(m, ypr->x, ypr->y, ypr->z);
 }
 
-/* xMat3x3Euler (xMat3x3 *, float, float, float) */
 void xMat3x3Euler(xMat3x3* m, F32 yaw, F32 pitch, F32 roll)
 {
     F32 temp_f0;
@@ -208,7 +308,6 @@ void xMat3x3Euler(xMat3x3* m, F32 yaw, F32 pitch, F32 roll)
     m->flags = 0;
 }
 
-/* xMat3x3RotC (xMat3x3 *, float, float, float, float) */
 void xMat3x3RotC(xMat3x3* m, F32 _x, F32 _y, F32 _z, F32 t)
 {
     F32 sin;
@@ -276,128 +375,195 @@ void xMat3x3RotZ(xMat3x3* m, F32 t)
     m->flags = 0;
 }
 
-/* xMat3x3Normalize (xMat3x3 *, xMat3x3 const *) */
-void xMat3x3Normalize(xMat3x3* o, const xMat3x3* m)
+void xMat3x3ScaleC(xMat3x3* m, F32 x, F32 y, F32 z)
 {
-    xVec3Normalize((xVec3*)o, (xVec3*)m);
-    xVec3Normalize(&o->up, &m->up);
-    xVec3Normalize(&o->at, &m->at);
+    xVec3Init((xVec3*)m, x, 0.0f, 0.0f);
+    xVec3Init(&m->up, 0.0f, y, 0.0f);
+    xVec3Init(&m->at, 0.0f, 0.0f, z);
+    m->flags = 0;
 }
 
-/* xMat3x3Tolocal (xVec3 *, xMat3x3 const *, xVec3 const *) */
-void xMat3x3Tolocal(xVec3* o, const xMat3x3* m, const xVec3* v)
+void xMat3x3RMulRotY(xMat3x3* o, const xMat3x3* m, F32 t)
 {
-    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);
-    xMat3x3LMulVec(o, m, v);
-    o->x /= sumRt;
-    o->y /= sumUp;
-    o->z /= sumAt;
-}
+    F32 cos = icos(t);
+    F32 sin = isin(t);
+    if (o == m)
+    {
+        F32 temp = o->right.z;
+        o->right.z = ((cos * o->right.z) - (sin * o->right.x));
+        o->right.x = ((cos * o->right.x) + (sin * temp));
 
-/* xMat4x3MoveLocalRight (xMat4x3 *, float) */
-void xMat4x3MoveLocalRight(xMat4x3* m, F32 mag)
-{
-    m->pos.x += m->right.x * mag;
-    m->pos.y += m->right.y * mag;
-    m->pos.z += m->right.z * mag;
-}
+        temp = o->up.z;
+        o->up.z = ((cos * temp) - (sin * o->up.x));
+        o->up.x = ((cos * o->up.x) + (sin * temp));
 
-/* xMat4x3MoveLocalAt (xMat4x3 *, float) */
-void xMat4x3MoveLocalAt(xMat4x3* m, F32 mag)
-{
-    m->pos.x += m->at.x * mag;
-    m->pos.y += m->at.y * mag;
-    m->pos.z += m->at.z * mag;
+        temp = o->at.z;
+        o->at.z = ((cos * temp) - (sin * o->at.x));
+        o->at.x = ((cos * o->at.x) + (sin * temp));
+    }
+    else
+    {
+        o->right.x = (cos * m->right.x + (sin * m->right.z));
+        o->right.y = m->right.y;
+        o->right.z = (cos * m->right.z - (sin * m->right.x));
+
+        o->up.x = (cos * m->up.x + (sin * m->up.z));
+        o->up.y = m->up.y;
+        o->up.z = (cos * m->up.z - (sin * m->up.x));
+
+        o->at.x = (cos * m->at.x + (sin * m->at.z));
+        o->at.y = m->at.y;
+        o->at.z = (cos * m->at.z - (sin * m->at.x));
+
+        o->flags = 0;
+    }
 }
 
-/* xMat4x3MoveLocalUp (xMat4x3 *, float) */
-void xMat4x3MoveLocalUp(xMat4x3* m, F32 mag)
+void xMat3x3Transpose(xMat3x3* o, const xMat3x3* m)
 {
-    m->pos.x += m->up.x * mag;
-    m->pos.y += m->up.y * mag;
-    m->pos.z += m->up.z * mag;
+    F32 temp;
+
+    if (o == m)
+    {
+        temp = o->right.y;
+        o->right.y = o->up.x;
+        o->up.x = temp;
+
+        temp = o->right.z;
+        o->right.z = o->at.x;
+        o->at.x = temp;
+
+        temp = o->up.z;
+        o->up.z = o->at.y;
+        o->at.y = temp;
+
+        return;
+    }
+
+    o->right.x = m->right.x;
+    o->right.y = m->up.x;
+    o->right.z = m->at.x;
+
+    o->up.x = m->right.y;
+    o->up.y = m->up.y;
+    o->up.z = m->at.y;
+
+    o->at.x = m->right.z;
+    o->at.y = m->up.z;
+    o->at.z = m->at.z;
+
+    o->flags = 0;
 }
 
-/* xMat3x3GetEuler (xMat3x3 const *, xVec3 *) */
-void xMat3x3GetEuler(const xMat3x3* m, xVec3* a)
+void xMat3x3Mul(xMat3x3* o, const xMat3x3* a, const xMat3x3* b)
 {
-    F32 yaw = -xasin(m->at.y);
-
-    F32 roll;
-    F32 pitch;
+    xMat3x3 sp8;
+    F32 temp_f0;
+    F32 temp_f0_2;
+    F32 temp_f10;
+    F32 temp_f10_2;
+    F32 temp_f12;
+    F32 temp_f13;
+    F32 temp_f1;
+    F32 temp_f25;
+    F32 temp_f26;
+    F32 temp_f27;
+    F32 temp_f29;
+    F32 temp_f2;
+    F32 temp_f30;
+    F32 temp_f3;
+    F32 temp_f4;
+    F32 temp_f4_2;
+    F32 temp_f5;
+    F32 temp_f9;
+    U8 var_r0;
+    xMat3x3* var_r6;
 
-    if (yaw < (PI / 2))
+    var_r0 = 0;
+    if ((o == a) || (o == b))
     {
-        if (yaw > -(PI / 2))
-        {
-            pitch = xatan2(m->at.x, m->at.z);
-            roll = xatan2(m->right.y, m->up.y);
-        }
-        else
-        {
-            pitch = -xatan2(-m->up.x, m->right.x);
-            roll = 0.0f;
-        }
+        var_r0 = 1;
+    }
+    if (var_r0 != 0)
+    {
+        var_r6 = &sp8;
     }
     else
     {
-        pitch = xatan2(-m->up.x, m->right.x);
-        roll = 0.0f;
+        var_r6 = o;
     }
-
-    a->x = pitch;
-    a->y = yaw;
-    a->z = roll;
+    temp_f4 = a->right.y;
+    temp_f3 = b->up.x;
+    temp_f2 = b->up.y;
+    temp_f1 = a->up.y;
+    temp_f10 = b->up.z;
+    temp_f0 = a->at.y;
+    temp_f26 = a->right.x;
+    temp_f27 = b->right.x;
+    temp_f30 = b->right.y;
+    temp_f9 = a->up.x;
+    temp_f12 = b->right.z;
+    temp_f4_2 = a->at.x;
+    temp_f25 = a->right.z;
+    temp_f0_2 = b->at.x;
+    temp_f29 = b->at.y;
+    temp_f13 = b->at.z;
+    temp_f10_2 = a->up.z;
+    temp_f5 = a->at.z;
+    var_r6->right.x = (temp_f25 * temp_f0_2) + ((temp_f26 * temp_f27) + (temp_f4 * temp_f3));
+    var_r6->flags = 0;
+    var_r6->right.y = (temp_f25 * temp_f29) + ((temp_f26 * temp_f30) + (temp_f4 * temp_f2));
+    var_r6->right.z = (temp_f25 * temp_f13) + ((temp_f26 * temp_f12) + (temp_f4 * temp_f10));
+    var_r6->up.x = (temp_f10_2 * temp_f0_2) + ((temp_f9 * temp_f27) + (temp_f1 * temp_f3));
+    var_r6->up.y = (temp_f10_2 * temp_f29) + ((temp_f9 * temp_f30) + (temp_f1 * temp_f2));
+    var_r6->up.z = (temp_f10_2 * temp_f13) + ((temp_f9 * temp_f12) + (temp_f1 * temp_f10));
+    var_r6->at.x = (temp_f5 * temp_f0_2) + ((temp_f4_2 * temp_f27) + (temp_f0 * temp_f3));
+    var_r6->at.y = (temp_f5 * temp_f29) + ((temp_f4_2 * temp_f30) + (temp_f0 * temp_f2));
+    var_r6->at.z = (temp_f5 * temp_f13) + ((temp_f4_2 * temp_f12) + (temp_f0 * temp_f10));
+    // if (var_r0 != 0) {
+    //     xMat3x3Copy__FP7xMat3x3PC7xMat3x3(o, var_r6);
+    // }
 }
 
-/* xMat3x3Euler (xMat3x3 *, xVec3 const *) */
-void xMat3x3Euler(xMat3x3* m, const xVec3* ypr)
+void xMat3x3LMulVec(xVec3* o, const xMat3x3* m, const xVec3* v)
 {
-    xMat3x3Euler(m, ypr->x, ypr->y, ypr->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->y = y;
+    o->z = z;
 }
 
-/* xQuatToMat (xQuat const *, xMat3x3 *) */
-void xQuatToMat(const xQuat* q, xMat3x3* m)
+void xMat3x3Tolocal(xVec3* o, const xMat3x3* m, const xVec3* v)
 {
-    F32 tx = (2.0f * q->v.x);
-    F32 ty = (2.0f * q->v.y);
-    F32 tz = (2.0f * q->v.z);
-    F32 tsx = tx * q->s;
-    F32 tsy = ty * q->s;
-    F32 tsz = tz * q->s;
-    F32 txx = tx * q->v.x;
-    F32 txy = ty * q->v.x;
-    F32 txz = tz * q->v.x;
-    F32 tyy = ty * q->v.y;
-    F32 tyz = tz * q->v.y;
-    F32 tzz = tz * q->v.z;
-
-    m->right.x = (1.0f - tyy) - tzz;
-    m->right.y = txy - tsz;
-    m->right.z = txz + tsy;
-
-    m->up.x = txy + tsz;
-    m->up.y = (1.0f - tzz) - txx;
-    m->up.z = tyz - tsx;
+    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);
+    xMat3x3LMulVec(o, m, v);
+    o->x /= sumRt;
+    o->y /= sumUp;
+    o->z /= sumAt;
+}
 
-    m->at.x = txz - tsy;
-    m->at.y = tyz + tsx;
-    m->at.z = (1.0f - txx) - tyy;
+void xMat4x3Rot(xMat4x3* m, const xVec3* a, F32 t, const xVec3* p)
+{
+    xMat4x3 temp;
 
-    m->flags = 0;
+    xMat3x3RotC(m, a->x, a->y, a->z, t);
+    xVec3Copy(&m->pos, p);
+    xMat3x3Identity(&temp);
+    xVec3Inv(&temp.pos, p);
+    xMat4x3Mul(m, &temp, m);
 }
 
-/* xQuatDiff (xQuat *, xQuat const *, xQuat const *) */
-void xQuatDiff(xQuat* o, const xQuat* a, const xQuat* b)
+void xMat4x3Mul(xMat4x3* o, const xMat4x3* a, const xMat4x3* b)
 {
-    xQuatConj(o, a);
-    xQuatMul(o, o, b);
-    if (o->s < 0.0f)
-    {
-        xQuatFlip(o, o);
-    }
+    xVec3 sp8;
+
+    xMat4x3Toworld(&sp8, b, &a->pos);
+    xMat3x3Mul((xMat3x3*)o, (xMat3x3*)a, (xMat3x3*)b);
+    xVec3Copy(&o->pos, &sp8);
 }
 
 // Matching in Ratatouille, minus debug stuff: https://decomp.me/scratch/VthMZ
@@ -450,20 +616,50 @@ void xQuatFromMat(xQuat* q, const xMat3x3* m)
     }
 }
 
-void xQuatFromAxisAngle(xQuat* q, const xVec3* a, F32 t)
-{
-    F32 t_2;
+void xQuatFromAxisAngle(xQuat* q, const xVec3* a, F32 t)
+{
+    F32 t_2;
+
+    if (t == 0.0f)
+    {
+        xQuatCopy(q, &g_IQ);
+    }
+    else
+    {
+        t_2 = isin(t * 0.5f);
+        q->s = icos((t * 0.5f));
+        xVec3SMul(&q->v, a, t_2);
+    }
+}
+
+void xQuatToMat(const xQuat* q, xMat3x3* m)
+{
+    F32 tx = (2.0f * q->v.x);
+    F32 ty = (2.0f * q->v.y);
+    F32 tz = (2.0f * q->v.z);
+    F32 tsx = tx * q->s;
+    F32 tsy = ty * q->s;
+    F32 tsz = tz * q->s;
+    F32 txx = tx * q->v.x;
+    F32 txy = ty * q->v.x;
+    F32 txz = tz * q->v.x;
+    F32 tyy = ty * q->v.y;
+    F32 tyz = tz * q->v.y;
+    F32 tzz = tz * q->v.z;
+
+    m->right.x = (1.0f - tyy) - tzz;
+    m->right.y = txy - tsz;
+    m->right.z = txz + tsy;
+
+    m->up.x = txy + tsz;
+    m->up.y = (1.0f - tzz) - txx;
+    m->up.z = tyz - tsx;
+
+    m->at.x = txz - tsy;
+    m->at.y = tyz + tsx;
+    m->at.z = (1.0f - txx) - tyy;
 
-    if (t == 0.0f)
-    {
-        xQuatCopy(q, &g_IQ);
-    }
-    else
-    {
-        t_2 = isin(t * 0.5f);
-        q->s = icos((t * 0.5f));
-        xVec3SMul(&q->v, a, t_2);
-    }
+    m->flags = 0;
 }
 
 void xQuatToAxisAngle(const xQuat* q, xVec3* a, F32* t)
@@ -500,7 +696,6 @@ F32 xQuatNormalize(xQuat* o, const xQuat* q)
     return len;
 }
 
-/* xQuatSlerp (xQuat *, xQuat const *, xQuat const *, float) */
 void xQuatSlerp(xQuat* q, const xQuat* a, const xQuat* b, F32 t)
 {
     xQuat sp28;
@@ -554,7 +749,6 @@ void xQuatSlerp(xQuat* q, const xQuat* a, const xQuat* b, F32 t)
     xQuatNormalize(q, q);
 }
 
-/* xQuatMul (xQuat *, xQuat const *, xQuat const *) */
 void xQuatMul(xQuat* o, const xQuat* a, const xQuat* b)
 {
     F32 temp_f10;
@@ -585,252 +779,61 @@ void xQuatMul(xQuat* o, const xQuat* a, const xQuat* b)
     xQuatNormalize(o, o);
 }
 
-/* xQuatSMul (xQuat *, xQuat const *, float) */
-void xQuatSMul(xQuat* q, const xQuat* a, F32 t)
-{
-    q->s = a->s * t;
-    xVec3SMul((xVec3*)q, (xVec3*)a, t);
-}
-
-/* xQuatAdd (xQuat *, xQuat const *, xQuat const *) */
-void xQuatAdd(xQuat* q, const xQuat* a, const xQuat* b)
-{
-    q->s = a->s + b->s;
-    xVec3Add((xVec3*)q, (xVec3*)a, (xVec3*)b);
-}
-
-/* xMat3x3LookVec (xMat3x3 *, xVec3 const *) */
-F32 xMat3x3LookVec(xMat3x3* m, const xVec3* at)
+void xQuatDiff(xQuat* o, const xQuat* a, const xQuat* b)
 {
-    F32 temp_f2;
-    F32 temp_f31;
-    xVec3* temp_r3;
-
-    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)
-    {
-        m->right.x = 1.0f;
-        m->right.y = 0.0f;
-        m->right.z = 0.0f;
-        m->up.x = 0.0f;
-        m->up.y = 0.0f;
-        m->up.z = 1.0f;
-        m->at.x = 0.0f;
-        m->at.y = -1.0f;
-        m->at.z = 0.0f;
-        return temp_f31;
-    }
-    if ((F32)__fabs(1.0f + m->at.y) < 0.00001f)
-    {
-        m->right.x = -1.0f;
-        m->right.y = 0.0f;
-        m->right.z = 0.0f;
-        m->up.x = 0.0f;
-        m->up.y = 0.0f;
-        m->up.z = -1.0f;
-        m->at.x = 0.0f;
-        m->at.y = 1.0f;
-        m->at.z = 0.0f;
-        return temp_f31;
-    }
-    if (((F32)__fabs(at->z) < 0.00001f) && ((F32)__fabs(at->x) < 0.00001f))
+    xQuatConj(o, a);
+    xQuatMul(o, o, b);
+    if (o->s < 0.0f)
     {
-        m->right.x = 1.0f;
-        m->right.y = 0.0f;
-        m->right.z = 0.0f;
-        m->up.x = 0.0f;
-        m->up.y = 1.0f;
-        m->up.z = 0.0f;
-        m->at.x = 0.0f;
-        m->at.y = 0.0f;
-        m->at.z = 1.0f;
-        return 0.0f;
+        xQuatFlip(o, o);
     }
-    m->right.x = m->at.z;
-    m->right.y = 0.0f;
-    m->right.z = -m->at.x;
-    xVec3Normalize((xVec3*)m, (xVec3*)m);
-    xVec3Cross(&m->up, &m->at, (xVec3*)m);
-    xVec3Cross((xVec3*)m, &m->up, &m->at);
-    m->flags = 0;
-    return temp_f31;
-}
-
-/* xMat3x3ScaleC (xMat3x3 *, float, float, float) */
-void xMat3x3ScaleC(xMat3x3* m, F32 x, F32 y, F32 z)
-{
-    xVec3Init((xVec3*)m, x, 0.0f, 0.0f);
-    xVec3Init(&m->up, 0.0f, y, 0.0f);
-    xVec3Init(&m->at, 0.0f, 0.0f, z);
-    m->flags = 0;
 }
 
-void xMat3x3RMulRotY(xMat3x3* o, const xMat3x3* m, F32 t)
+void xBoxUnion(xBox& a, const xBox& b, const xBox& c)
 {
-    F32 cos = icos(t);
-    F32 sin = isin(t);
-    if (o == m)
-    {
-        F32 temp = o->right.z;
-        o->right.z = ((cos * o->right.z) - (sin * o->right.x));
-        o->right.x = ((cos * o->right.x) + (sin * temp));
-
-        temp = o->up.z;
-        o->up.z = ((cos * temp) - (sin * o->up.x));
-        o->up.x = ((cos * o->up.x) + (sin * temp));
-
-        temp = o->at.z;
-        o->at.z = ((cos * temp) - (sin * o->at.x));
-        o->at.x = ((cos * o->at.x) + (sin * temp));
-    }
-    else
-    {
-        o->right.x = (cos * m->right.x + (sin * m->right.z));
-        o->right.y = m->right.y;
-        o->right.z = (cos * m->right.z - (sin * m->right.x));
-
-        o->up.x = (cos * m->up.x + (sin * m->up.z));
-        o->up.y = m->up.y;
-        o->up.z = (cos * m->up.z - (sin * m->up.x));
-
-        o->at.x = (cos * m->at.x + (sin * m->at.z));
-        o->at.y = m->at.y;
-        o->at.z = (cos * m->at.z - (sin * m->at.x));
+    a.upper.x = MAX(b.upper.x, c.upper.x);
+    a.upper.y = MAX(b.upper.y, c.upper.y);
+    a.upper.z = MAX(b.upper.z, c.upper.z);
 
-        o->flags = 0;
-    }
+    a.lower.x = MIN(b.lower.x, c.lower.x);
+    a.lower.y = MIN(b.lower.y, c.lower.y);
+    a.lower.z = MIN(b.lower.z, c.lower.z);
 }
 
-void xMat3x3Transpose(xMat3x3* o, const xMat3x3* m)
+void xBoxFromCircle(xBox& o, const xVec3& a, const xVec3& b, F32 r)
 {
-    F32 temp;
-
-    if (o == m)
-    {
-        temp = o->right.y;
-        o->right.y = o->up.x;
-        o->up.x = temp;
-
-        temp = o->right.z;
-        o->right.z = o->at.x;
-        o->at.x = temp;
-
-        temp = o->up.z;
-        o->up.z = o->at.y;
-        o->at.y = temp;
-
-        return;
-    }
-
-    o->right.x = m->right.x;
-    o->right.y = m->up.x;
-    o->right.z = m->at.x;
-
-    o->up.x = m->right.y;
-    o->up.y = m->up.y;
-    o->up.z = m->at.y;
-
-    o->at.x = m->right.z;
-    o->at.y = m->up.z;
-    o->at.z = m->at.z;
+    F32 temp1;
+    F32 temp2;
+    F32 temp3;
+    xVec3 temp_vec1;
+    xVec3 temp_vec2;
 
-    o->flags = 0;
+    temp1 = r * xsqrt(1.0f - (b.x * b.x));
+    temp2 = r * xsqrt(1.0f - (b.y * b.y));
+    temp3 = r * xsqrt(1.0f - (b.z * b.z));
+    temp_vec1 += a;
+    o.upper = temp_vec1;
+    temp_vec2 -= a;
+    o.lower = temp_vec2;
 }
 
-/* xMat3x3Mul (xMat3x3 *, xMat3x3 const *, xMat3x3 const *) */
-void xMat3x3Mul(xMat3x3* o, const xMat3x3* a, const xMat3x3* b)
+void xQuatSMul(xQuat* q, const xQuat* a, F32 t)
 {
-    xMat3x3 sp8;
-    F32 temp_f0;
-    F32 temp_f0_2;
-    F32 temp_f10;
-    F32 temp_f10_2;
-    F32 temp_f12;
-    F32 temp_f13;
-    F32 temp_f1;
-    F32 temp_f25;
-    F32 temp_f26;
-    F32 temp_f27;
-    F32 temp_f29;
-    F32 temp_f2;
-    F32 temp_f30;
-    F32 temp_f3;
-    F32 temp_f4;
-    F32 temp_f4_2;
-    F32 temp_f5;
-    F32 temp_f9;
-    U8 var_r0;
-    xMat3x3* var_r6;
-
-    var_r0 = 0;
-    if ((o == a) || (o == b))
-    {
-        var_r0 = 1;
-    }
-    if (var_r0 != 0)
-    {
-        var_r6 = &sp8;
-    }
-    else
-    {
-        var_r6 = o;
-    }
-    temp_f4 = a->right.y;
-    temp_f3 = b->up.x;
-    temp_f2 = b->up.y;
-    temp_f1 = a->up.y;
-    temp_f10 = b->up.z;
-    temp_f0 = a->at.y;
-    temp_f26 = a->right.x;
-    temp_f27 = b->right.x;
-    temp_f30 = b->right.y;
-    temp_f9 = a->up.x;
-    temp_f12 = b->right.z;
-    temp_f4_2 = a->at.x;
-    temp_f25 = a->right.z;
-    temp_f0_2 = b->at.x;
-    temp_f29 = b->at.y;
-    temp_f13 = b->at.z;
-    temp_f10_2 = a->up.z;
-    temp_f5 = a->at.z;
-    var_r6->right.x = (temp_f25 * temp_f0_2) + ((temp_f26 * temp_f27) + (temp_f4 * temp_f3));
-    var_r6->flags = 0;
-    var_r6->right.y = (temp_f25 * temp_f29) + ((temp_f26 * temp_f30) + (temp_f4 * temp_f2));
-    var_r6->right.z = (temp_f25 * temp_f13) + ((temp_f26 * temp_f12) + (temp_f4 * temp_f10));
-    var_r6->up.x = (temp_f10_2 * temp_f0_2) + ((temp_f9 * temp_f27) + (temp_f1 * temp_f3));
-    var_r6->up.y = (temp_f10_2 * temp_f29) + ((temp_f9 * temp_f30) + (temp_f1 * temp_f2));
-    var_r6->up.z = (temp_f10_2 * temp_f13) + ((temp_f9 * temp_f12) + (temp_f1 * temp_f10));
-    var_r6->at.x = (temp_f5 * temp_f0_2) + ((temp_f4_2 * temp_f27) + (temp_f0 * temp_f3));
-    var_r6->at.y = (temp_f5 * temp_f29) + ((temp_f4_2 * temp_f30) + (temp_f0 * temp_f2));
-    var_r6->at.z = (temp_f5 * temp_f13) + ((temp_f4_2 * temp_f12) + (temp_f0 * temp_f10));
-    // if (var_r0 != 0) {
-    //     xMat3x3Copy__FP7xMat3x3PC7xMat3x3(o, var_r6);
-    // }
+    q->s = a->s * t;
+    xVec3SMul((xVec3*)q, (xVec3*)a, t);
 }
 
-void xMat3x3SMul(xMat3x3*, const xMat3x3*, F32)
+F32 xQuatLength2(const xQuat* q)
 {
+    return xQuatDot(q, q);
 }
 
-void xBoxUnion(xBox& a, const xBox& b, const xBox& c)
+void xQuatAdd(xQuat* q, const xQuat* a, const xQuat* b)
 {
-    a.upper.x = MAX(b.upper.x, c.upper.x);
-    a.upper.y = MAX(b.upper.y, c.upper.y);
-    a.upper.z = MAX(b.upper.z, c.upper.z);
-
-    a.lower.x = MIN(b.lower.x, c.lower.x);
-    a.lower.y = MIN(b.lower.y, c.lower.y);
-    a.lower.z = MIN(b.lower.z, c.lower.z);
+    q->s = a->s + b->s;
+    xVec3Add((xVec3*)q, (xVec3*)a, (xVec3*)b);
 }
 
-void xMat3x3LMulVec(xVec3* o, const xMat3x3* m, const xVec3* v)
+void xMat3x3SMul(xMat3x3*, const xMat3x3*, F32)
 {
-    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->y = y;
-    o->z = z;
 }
diff --git a/src/SB/Core/x/xMath3.h b/src/SB/Core/x/xMath3.h
index fc7728676..203d69b19 100644
--- a/src/SB/Core/x/xMath3.h
+++ b/src/SB/Core/x/xMath3.h
@@ -132,63 +132,66 @@ extern xMat4x3 g_I3;
 
 void xMath3Init();
 void xLine3VecDist2(const xVec3* p1, const xVec3* p2, const xVec3* v, xIsect* isx);
+S32 xPointInBox(const xBox* b, const xVec3* p);
 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);
+void xMat3x3Normalize(xMat3x3* o, const xMat3x3* m);
+void xMat3x3GetEuler(const xMat3x3* m, xVec3* a);
+void xMat4x3MoveLocalRight(xMat4x3* m, F32 mag);
+void xMat4x3MoveLocalUp(xMat4x3* m, F32 mag);
+void xMat4x3MoveLocalAt(xMat4x3* m, F32 mag);
+F32 xMat3x3LookVec(xMat3x3* m, const xVec3* at);
+void xMat3x3Euler(xMat3x3* m, const xVec3* ypr);
 void xMat3x3Euler(xMat3x3* m, F32 yaw, F32 pitch, F32 roll);
-void xMat4x3Toworld(xVec3* o, const xMat4x3* m, const xVec3* v);
 void xMat3x3RotC(xMat3x3* m, F32 _x, F32 _y, F32 _z, F32 t);
 void xMat3x3RotX(xMat3x3* m, F32 t);
 void xMat3x3RotY(xMat3x3* m, F32 t);
 void xMat3x3RotZ(xMat3x3* m, F32 t);
+void xMat3x3ScaleC(xMat3x3* m, F32 x, F32 y, F32 z);
+void xMat3x3RMulRotY(xMat3x3* o, const xMat3x3* m, F32 t);
+void xMat3x3Transpose(xMat3x3* o, const xMat3x3* m);
+void xMat3x3Mul(xMat3x3* o, const xMat3x3* a, const xMat3x3* b);
+void xMat3x3LMulVec(xVec3* o, const xMat3x3* m, const xVec3* v);
+void xMat3x3Tolocal(xVec3* o, const xMat3x3* m, const xVec3* v);
+void xMat4x3Rot(xMat4x3* m, const xVec3* a, F32 t, const xVec3* p);
+void xMat4x3Mul(xMat4x3* o, const xMat4x3* a, const xMat4x3* b);
+void xQuatFromMat(xQuat* q, const xMat3x3* m);
+void xQuatFromAxisAngle(xQuat* q, const xVec3* a, F32 t);
+void xQuatToMat(const xQuat* q, xMat3x3* m);
+void xQuatToAxisAngle(const xQuat* q, xVec3* a, F32* t);
+F32 xQuatNormalize(xQuat* o, const xQuat* q);
+void xQuatSlerp(xQuat* q, const xQuat* a, const xQuat* b, F32 t);
+void xQuatMul(xQuat* o, const xQuat* a, const xQuat* b);
+void xQuatDiff(xQuat* o, const xQuat* a, const xQuat* b);
+
+void xBoxUnion(xBox& a, const xBox& b, const xBox& c);
+void xBoxFromCircle(xBox& o, const xVec3& a, const xVec3& b, F32 r);
+void xQuatSMul(xQuat* q, const xQuat* a, F32 t);
+F32 xQuatLength2(const xQuat* q);
+void xQuatAdd(xQuat* q, const xQuat* a, const xQuat* b);
+
+void xQuatCopy(xQuat*, const xQuat*);
+void xMat3x3SMul(xMat3x3*, const xMat3x3*, F32);
+void xQuatFlip(xQuat* o1, xQuat* o2);
+
+F32 xQuatDot(const xQuat* a, const xQuat* b);
+void xMat3x3Copy(xMat3x3* o, const xMat3x3* m); // TODO: These functions should be inline
+void xMat4x3Copy(xMat4x3* o, const xMat4x3* m);
+void xMat4x3Toworld(xVec3* o, const xMat4x3* m, const xVec3* v);
 void xMat3x3MulRotC(xMat3x3* o, xMat3x3* m, F32 _x, F32 _y, F32 _z, F32 t);
 void xMat4x3Identity(xMat4x3* m);
-void xMat3x3Normalize(xMat3x3* o, const xMat3x3* m);
 void xMat4x3Tolocal(xVec3* o, const xMat4x3* m, const xVec3* v);
-void xMat3x3Tolocal(xVec3* o, const xMat3x3* m, const xVec3* v);
-void xMat4x3MoveLocalRight(xMat4x3* m, F32 mag);
-void xMat4x3MoveLocalAt(xMat4x3* m, F32 mag);
-void xMat4x3MoveLocalUp(xMat4x3* m, F32 mag);
 void xMat4x3OrthoInv(xMat4x3* o, const xMat4x3* m);
-void xMat3x3GetEuler(const xMat3x3* m, xVec3* a);
-void xMat3x3Euler(xMat3x3* m, const xVec3* ypr);
-void xMat3x3Transpose(xMat3x3* o, const xMat3x3* m);
-void xQuatToMat(const xQuat* q, xMat3x3* m);
-void xQuatDiff(xQuat* o, const xQuat* a, const xQuat* b);
 F32 xQuatGetAngle(const xQuat* q);
-void xQuatFromMat(xQuat* q, const xMat3x3* m);
-void xQuatToAxisAngle(const xQuat* q, xVec3* a, F32* t);
-void xQuatSlerp(xQuat* q, const xQuat* a, const xQuat* b, F32 t);
 void xQuatConj(xQuat* o, const xQuat* q);
-void xQuatCopy(xQuat*, const xQuat*);
 void xMat3x3LookAt(xMat3x3* m, const xVec3* pos, const xVec3* at);
-F32 xMat3x3LookVec(xMat3x3* m, const xVec3* at);
 F32 xMat3x3LookVec3(xMat3x3& m, const xVec3& at);
-void xBoxInitBoundOBB(xBox* o, const xBox* b, const xMat4x3* m);
-void xBoxUnion(xBox& a, const xBox& b, const xBox& c);
 void xMat3x3Scale(xMat3x3* m, const xVec3* s);
-void xMat3x3ScaleC(xMat3x3* m, F32 x, F32 y, F32 z);
-void xMat3x3RMulRotY(xMat3x3* o, const xMat3x3* m, F32 t);
-void xMat3x3Mul(xMat3x3* o, const xMat3x3* a, const xMat3x3* b);
-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);
-F32 xQuatDot(const xQuat* a, const xQuat* b);
 
 F32 fabs(F32 x); // Unsure where this should come from.