diff --git a/include/common_structs.h b/include/common_structs.h
index c346e4af22..3798cb5c46 100644
--- a/include/common_structs.h
+++ b/include/common_structs.h
@@ -499,8 +499,9 @@ typedef struct Collider {
     /* 0x0A */ s16 numTriangles;
     /* 0x0C */ struct ColliderTriangle* triangleTable;
     /* 0x10 */ struct ColliderBoundingBox* aabb;
-    /* 0x14 */ char unk_14[4];
-    /* 0x18 */ f32* vertexTable; // 3?
+    /* 0x14 */ s16 numVertices;
+    /* 0x16 */ char unk_16[2];
+    /* 0x18 */ Vec3f* vertexTable; // contains local and global coordinates
 } Collider; // size = 0x1C
 
 typedef struct CameraInitData {
@@ -824,9 +825,9 @@ typedef struct StaticMove {
 } StaticMove; // size = 0x14
 
 typedef struct CollisionData {
-    /* 0x00 */ f32* vertices;
+    /* 0x00 */ Vec3f* vertices;
     /* 0x04 */ Collider* colliderList;
-    /* 0x08 */ struct ColliderBoundingBox** aabbs;
+    /* 0x08 */ struct ColliderBoundingBox* aabbs;
     /* 0x0C */ s16 numColliders;
     /* 0x0E */ char unk_0E[2];
 } CollisionData; // size = 0x10
@@ -927,8 +928,8 @@ typedef struct OtherPrint {
 } OtherPrint; // size = 0x54
 
 typedef struct ColliderBoundingBox {
-    /* 0x00 */ f32 min[3];
-    /* 0x0C */ f32 max[3];
+    /* 0x00 */ Vec3f min;
+    /* 0x0C */ Vec3f max;
     /* 0x18 */ s32 flagsForCollider;
 } ColliderBoundingBox; // size = 0x1C
 
diff --git a/include/functions.h b/include/functions.h
index a573dba61b..fe6a134b1f 100644
--- a/include/functions.h
+++ b/include/functions.h
@@ -146,7 +146,7 @@ MessagePrintState* msg_get_printer_for_msg(s32 msgID, s32* a1);
 
 void get_screen_coords(s32 camID, f32 x, f32 y, f32 z, s32* screenX, s32* screenY, s32* screenZ);
 
-void parent_collider_to_model(s32 colliderID, s16 modelIndex);
+void parent_collider_to_model(s16 colliderID, s16 modelIndex);
 void clone_model(u16 srcModelID, u16 newModelID);
 struct Model* get_model_from_list_index(s32 listIndex);
 s32 get_model_list_index_from_tree_index(s32 treeIndex);
diff --git a/include/map.h b/include/map.h
index 6eff9b1c96..5b34953d0e 100644
--- a/include/map.h
+++ b/include/map.h
@@ -14,8 +14,8 @@ typedef Vec4f EntryList[];
 /// Fields other than main, entryList, entryCount, background, and tattle are initialised when the map loads.
 typedef struct MapConfig {
     /* 0x00 */ struct ModelNode* modelTreeRoot;
-    /* 0x04 */ UNK_PTR collision;
-    /* 0x08 */ UNK_PTR unk_08;
+    /* 0x04 */ s32 hitAssetCollisionOffset;
+    /* 0x08 */ s32 hitAssetZoneOffset;
     /* 0x0C */ char unk_0C[4];
     /* 0x10 */ EvtSource* main;
     /* 0x14 */ EntryList* entryList;
diff --git a/src/362a0_len_2f70.c b/src/362a0_len_2f70.c
deleted file mode 100644
index d2b55e7522..0000000000
--- a/src/362a0_len_2f70.c
+++ /dev/null
@@ -1,208 +0,0 @@
-#include "common.h"
-
-extern s16 D_800D91DC;
-
-typedef struct {
-    UNK_PTR collision;
-    UNK_PTR unk_08;
-} HitAsset;
-
-void load_hit_data(s32 idx, HitAsset* hit);
-
-INCLUDE_ASM(s32, "362a0_len_2f70", allocate_hit_tables);
-
-void func_8005AF84(void) {
-}
-
-void func_8005AF8C(void) {
-}
-
-void initialize_collision(void) {
-    gCollisionData.numColliders = 0;
-    D_800D91DC = 0;
-    collision_heap_create();
-}
-
-void load_hit_asset(void) {
-    u32 assetSize;
-    MapConfig* map = get_current_map_header();
-    void* compressedData = load_asset_by_name(&wMapHitName, &assetSize);
-    HitAsset* uncompressedData = heap_malloc(assetSize);
-
-    decode_yay0(compressedData, uncompressedData);
-    general_heap_free(compressedData);
-
-    map->collision = uncompressedData->collision;
-    map->unk_08 = uncompressedData->unk_08;
-
-    load_hit_data(0, uncompressedData);
-    load_hit_data(1, uncompressedData);
-
-    heap_free(uncompressedData);
-}
-
-INCLUDE_ASM(s32, "362a0_len_2f70", load_collision);
-
-void load_stage_collision(const char* hitName) {
-    if (hitName == NULL) {
-        gCollisionData.numColliders = 0;
-    } else {
-        u32 assetSize;
-        MapConfig* map = get_current_map_header();
-        void* compressedData = load_asset_by_name(hitName, &assetSize);
-        HitAsset* uncompressedData = heap_malloc(assetSize);
-
-        decode_yay0(compressedData, uncompressedData);
-        general_heap_free(compressedData);
-
-        map->collision = uncompressedData->collision;
-
-        load_hit_data(0, uncompressedData);
-
-        heap_free(uncompressedData);
-    }
-}
-
-INCLUDE_ASM(void, "362a0_len_2f70", load_hit_data, s32 idx, HitAsset* hit);
-
-INCLUDE_ASM(void, "362a0_len_2f70", parent_collider_to_model, s32 colliderID, s16 modelIndex);
-
-void _add_hit_vert_to_buffer(f32** buf, f32* vert, s32* bufSize) {
-    s32 i;
-
-    for (i = 0; i < *bufSize; i++) {
-        if (buf[i] == vert) {
-            break;
-        }
-    }
-
-    if (i == *bufSize) {
-        buf[i] = vert;
-        (*bufSize)++;
-    }
-}
-
-s32 _get_hit_vert_index_from_buffer(f32** buffer, f32* vert, s32* bufferSize) {
-    s32 i;
-
-    for (i = 0; i < *bufferSize; i++) {
-        if (*buffer == vert) {
-            break;
-        }
-        buffer++;
-    }
-
-    return i;
-}
-
-INCLUDE_ASM(void, "362a0_len_2f70", update_collider_transform, s16 colliderID);
-
-s32 get_collider_type_by_id(s32 colliderID) {
-    if (colliderID & 0x4000) {
-        return 0;
-    } else {
-        return gCollisionData.colliderList[colliderID].flags;
-    }
-}
-
-void get_flat_collider_normal(s32 colliderID, f32* x, f32* y, f32* z) {
-    ColliderTriangle* triangle = &gCollisionData.colliderList[colliderID].triangleTable[0];
-
-    *x = triangle->normal.x;
-    *y = triangle->normal.y;
-    *z = triangle->normal.z;
-}
-
-void get_collider_center(s32 colliderID, f32* x, f32* y, f32* z) {
-    ColliderBoundingBox* aabb = gCollisionData.colliderList[colliderID].aabb;
-
-    *x = (aabb->min[0] + aabb->max[0]) * 0.5f;
-    *y = (aabb->min[1] + aabb->max[1]) * 0.5f;
-    *z = (aabb->min[2] + aabb->max[2]) * 0.5f;
-}
-
-INCLUDE_ASM(s32, "362a0_len_2f70", test_ray_triangle_general);
-
-INCLUDE_ASM(s32, "362a0_len_2f70", test_down_ray_triangle);
-
-s32 test_up_ray_triangle(ColliderTriangle* triangle, f32* vertices);
-INCLUDE_ASM(s32, "362a0_len_2f70", test_up_ray_triangle, ColliderTriangle* triangle, f32* vertices);
-
-INCLUDE_ASM(s32, "362a0_len_2f70", test_ray_colliders, s32 ignoreFlags, f32 startX, f32 startY, f32 startZ, f32 dirX,
-            f32 dirY, f32 dirZ, f32* hitX, f32* hitY, f32* hitZ, f32* hitDepth, f32* hitNx, f32* hitNy, f32* hitNz);
-
-INCLUDE_ASM(s32, "362a0_len_2f70", test_ray_zones, f32 startX, f32 startY, f32 startZ, f32 dirX, f32 dirY, f32 dirZ,
-            f32* hitX, f32* hitY, f32* hitZ, f32* hitDepth, f32* nx, f32* ny, f32* nz);
-
-//s32 test_up_ray_collider(s32 ignoreFlags, s32 colliderID, f32 x, f32 y, f32 z, f32 length, f32 yaw);
-// Close, but no cigar
-extern f32 D_800A4230;
-extern f32 D_800A4234;
-extern f32 D_800A4238;
-extern f32 D_800A423C;
-extern s32 D_800A4240;
-extern f32 D_800A4244;
-extern f32 D_800A4254;
-
-#ifdef NON_EQUIVALENT
-f32 test_up_ray_collider(s32 ignoreFlags, s32 colliderID, f32 x, f32 y, f32 z, f32 length, f32 yaw) {
-    CollisionData* collisionData = &gCollisionData;
-    f32 cosTheta;
-    f32 sinTheta;
-    Collider* collider;
-    ColliderTriangle* triangleTable;
-    s32 i;
-    f32 ret;
-
-    sin_cos_rad(yaw * TAU / 360.0f, &sinTheta, &cosTheta);
-    collider = &collisionData->colliderList[colliderID];
-
-    D_800A4240 = 0;
-    D_800A4230 = x;
-    D_800A4234 = y;
-    D_800A4238 = z;
-    D_800A4254 = length;
-    D_800A423C = sinTheta;
-    D_800A4244 = -cosTheta;
-    ret = -1.0f;
-
-
-    if (!(collider->flags & ignoreFlags)) {
-        if (collider->numTriangles != 0) {
-            triangleTable = collider->triangleTable;
-
-            for (i = 0; i < collider->numTriangles; i++) {
-                if (test_up_ray_triangle(&triangleTable[i], collisionData->vertices)) {
-                    ret = D_800A4254;
-                }
-            }
-        }
-    }
-    return ret;
-}
-#else
-INCLUDE_ASM(s32, "362a0_len_2f70", test_up_ray_collider, s32 ignoreFlags, s32 colliderID, f32 x, f32 y, f32 z, f32 length, f32 yaw);
-#endif
-
-INCLUDE_ASM(s32, "362a0_len_2f70", test_ray_entities, f32 startX, f32 startY, f32 startZ, f32 dirX, f32 dirY, f32 dirZ,
-            f32* hitX, f32* hitY, f32* hitZ, f32* hitDepth, f32* hitNx, f32* hitNy, f32* hitNz);
-
-INCLUDE_ASM(s32, "362a0_len_2f70", func_8005DB00);
-
-ApiStatus func_8005DD54(Evt* script, s32 isInitialCall) {
-    f32 angle = clamp_angle(script->varTable[0]);
-
-    script->varTable[0] = angle;
-    if (angle >= 180.0f) {
-        angle -= 180.0f;
-    }
-    if (angle >= 90.0f) {
-        angle = 180.0f - angle;
-    }
-    script->varTable[2] = (s32) (((90.0f - angle) * 95.0f) / 90.0f) + 160;
-    return ApiStatus_DONE2;
-}
-
-s32 func_8005DDF0(void) {
-    return ~gCurrentEncounter.unk_08 != 0;
-}
diff --git a/src/bss.c b/src/bss.c
index 62293319ba..2764fadbc8 100644
--- a/src/bss.c
+++ b/src/bss.c
@@ -199,21 +199,21 @@ BSS s32 gMap;
 BSS char D_800A41E4[0x4];
 BSS s32 gMapConfig;
 BSS char D_800A41EC[0x44];
-BSS float D_800A4230;
-BSS float D_800A4234;
-BSS float D_800A4238;
-BSS float D_800A423C;
-BSS s32 D_800A4240;
-BSS float D_800A4244;
-BSS s32 D_800A4248;
-BSS s32 D_800A424C;
-BSS s32 D_800A4250;
-BSS float D_800A4254;
-BSS s32 D_800A4258;
-BSS s32 D_800A425C;
-BSS s32 D_800A4260;
-BSS s32 D_800A4264;
-BSS s32 D_800A4268;
+BSS float gCollisionRayStartX;
+BSS float gCollisionRayStartY;
+BSS float gCollisionRayStartZ;
+BSS float gCollisionRayDirX;
+BSS float gCollisionRayDirY;
+BSS float gCollisionRayDirZ;
+BSS float gCollisionPointX;
+BSS float gCollisionPointY;
+BSS float gCollisionPointZ;
+BSS float gCollisionRayLength;
+BSS s32 gCollisionNormalX;
+BSS s32 gCollisionNormalY;
+BSS s32 gCollisionNormalZ;
+BSS s32 gCollisionDataBackup;
+BSS s32 gCollisionDataZoneBackup;
 BSS char D_800A426C[0x4];
 BSS s8 D_800A4270[0x1B0];
 BSS s8 D_800A4420[0x21B0];
@@ -332,7 +332,7 @@ BSS s8 D_800B6590[0x2000];
 BSS u8 nuYieldBuf[0xC10];
 BSS s8 D_800B91A0[0x30];
 BSS s8 D_800B91D0[0x20000];
-BSS s32 D_800D91D0;
+BSS s32 gZoneCollisionData;
 BSS s32 D_800D91D4;
 BSS char D_800D91D8[0x4];
 BSS s16 D_800D91DC;
diff --git a/src/collision.c b/src/collision.c
new file mode 100644
index 0000000000..f0cf53dd92
--- /dev/null
+++ b/src/collision.c
@@ -0,0 +1,1081 @@
+#include "common.h"
+#include "model.h"
+
+typedef struct HitFile {
+    /* 0x00 */ u32 collisionOffset;
+    /* 0x04 */ u32 zoneOffset;
+} HitFile; // size = 0x08
+
+typedef struct ColliderBackupEntry {
+    /* 0x00 */ s32 flags;
+    /* 0x04 */ s16 parentModelIndex;
+    /* 0x06 */ s16 unk_06;
+} ColliderBackupEntry; // size = 0x08
+
+typedef struct HitFileHeader {
+    /* 0x00 */ s16 numColliders;
+    /* 0x02 */ s16 unk_02;
+    /* 0x04 */ s32 collidersOffset;
+    /* 0x08 */ s16 numVertices;
+    /* 0x0A */ s16 unk_0a;
+    /* 0x0C */ s32 verticesOffset;
+    /* 0x10 */ s16 boundingBoxesDataSize;
+    /* 0x12 */ s16 unk_12;
+    /* 0x14 */ s32 boundingBoxesOffset;
+} HitFileHeader; // size = 0x18
+
+typedef struct HitAssetCollider {
+    /* 0x00 */ s16 boundingBoxOffset;
+    /* 0x02 */ s16 nextSibling;
+    /* 0x04 */ s16 firstChild;
+    /* 0x06 */ s16 numTriangles;
+    /* 0x08 */ s32 trianglesOffset;
+} HitAssetCollider; // size = 0x0C
+
+typedef struct VertexIndexStruct {
+    /* 0x00 */ s16 i1;
+    /* 0x02 */ s16 i2;
+    /* 0x04 */ s16 i3;
+} VertexIndexStruct; // size = 0x06
+
+extern VertexIndexStruct gEntityColliderFaces[];
+extern Vec3f gEntityColliderNormals[];
+extern f32 gCollisionRayStartX;
+extern f32 gCollisionRayStartY;
+extern f32 gCollisionRayStartZ;
+extern f32 gCollisionRayDirX;
+extern f32 gCollisionRayDirY;
+extern f32 gCollisionRayDirZ;
+extern f32 gCollisionPointX;
+extern f32 gCollisionPointY;
+extern f32 gCollisionPointZ;
+extern f32 gCollisionRayLength;
+extern f32 gCollisionNormalX;
+extern f32 gCollisionNormalY;
+extern f32 gCollisionNormalZ;
+extern ColliderBackupEntry* gCollisionDataBackup;
+extern ColliderBackupEntry* gCollisionDataZoneBackup;
+extern CollisionData gZoneCollisionData;
+extern s16 D_800D91DC;
+
+s32 collision_heap_create(void);
+void* collision_heap_malloc(s32 size);
+void collision_heap_free(void*);
+
+void load_hit_data(s32 idx, HitFile* hit);
+void _add_hit_vert_to_buffer(Vec3f** buf, Vec3f* vert, s32* bufSize);
+s32 _get_hit_vert_index_from_buffer(Vec3f** buffer, Vec3f* vert, s32* bufferSize);
+
+void backup_map_collision_data(void) {
+    CollisionData* collisionData;
+    Collider* collider;
+    ColliderBackupEntry* backupEntry;
+    s32 i;
+
+    collisionData = &gCollisionData;
+    gCollisionDataBackup = general_heap_malloc(collisionData->numColliders * sizeof(ColliderBackupEntry));
+    for (i = 0, backupEntry = gCollisionDataBackup; i < collisionData->numColliders; i++, backupEntry++) {
+        collider = &collisionData->colliderList[i];
+        backupEntry->flags = collider->flags;
+        backupEntry->parentModelIndex = collider->parentModelIndex;
+    }
+
+    collisionData = &gZoneCollisionData;
+    gCollisionDataZoneBackup = general_heap_malloc(collisionData->numColliders * sizeof(ColliderBackupEntry));
+    for (i = 0, backupEntry = gCollisionDataZoneBackup; i < collisionData->numColliders; i++, backupEntry++) {
+        collider = &collisionData->colliderList[i];
+        backupEntry->flags = collider->flags;
+        backupEntry->parentModelIndex = collider->parentModelIndex;
+    }
+
+    D_800D91DC = 0;
+}
+
+void func_8005AF84(void) {
+}
+
+void func_8005AF8C(void) {
+}
+
+void initialize_collision(void) {
+    gCollisionData.numColliders = 0;
+    D_800D91DC = 0;
+    collision_heap_create();
+}
+
+void load_map_hit_asset(void) {
+    u32 assetSize;
+    MapConfig* map = get_current_map_header();
+    void* compressedData = load_asset_by_name(&wMapHitName, &assetSize);
+    HitFile* uncompressedData = heap_malloc(assetSize);
+
+    decode_yay0(compressedData, uncompressedData);
+    general_heap_free(compressedData);
+
+    map->hitAssetCollisionOffset = uncompressedData->collisionOffset;
+    map->hitAssetZoneOffset = uncompressedData->zoneOffset;
+
+    load_hit_data(0, uncompressedData);
+    load_hit_data(1, uncompressedData);
+
+    heap_free(uncompressedData);
+}
+
+void restore_map_collision_data(void) {
+    CollisionData* collisionData;
+    Collider* collider;
+    ColliderBackupEntry* backupEntry;
+    s32 i;
+
+    load_map_hit_asset();
+
+    collisionData = &gCollisionData;
+    for (i = 0, backupEntry = gCollisionDataBackup; i < collisionData->numColliders; i++, backupEntry++) {
+        collider = &collisionData->colliderList[i];
+        collider->flags = backupEntry->flags;
+        collider->parentModelIndex = backupEntry->parentModelIndex;
+
+        if (collider->flags != -1 && collider->flags & 0x80000000) {
+            parent_collider_to_model(i, collider->parentModelIndex);
+            update_collider_transform(i);
+        }
+    }
+
+    collisionData = &gZoneCollisionData;
+    for (i = 0, backupEntry = gCollisionDataZoneBackup; i < collisionData->numColliders; i++, backupEntry++) {
+        collider = &collisionData->colliderList[i];
+        collider->flags = backupEntry->flags;
+        collider->parentModelIndex = backupEntry->parentModelIndex;
+    }
+
+    general_heap_free(gCollisionDataBackup);
+    general_heap_free(gCollisionDataZoneBackup);
+}
+
+void load_battle_hit_asset(const char* hitName) {
+    if (hitName == NULL) {
+        gCollisionData.numColliders = 0;
+    } else {
+        u32 assetSize;
+        MapConfig* map = get_current_map_header();
+        void* compressedData = load_asset_by_name(hitName, &assetSize);
+        HitFile* uncompressedData = heap_malloc(assetSize);
+
+        decode_yay0(compressedData, uncompressedData);
+        general_heap_free(compressedData);
+
+        map->hitAssetCollisionOffset = uncompressedData->collisionOffset;
+
+        load_hit_data(0, uncompressedData);
+
+        heap_free(uncompressedData);
+    }
+}
+
+void load_hit_data(s32 idx, HitFile* hit) {
+    s32 collisionOffset;
+    MapConfig* map;
+    CollisionData* collisionData;
+    HitFileHeader* assetCollisionData;
+    Vec3f* vertices;
+    Vec3s* assetVertices;
+    u32* boundingBox;
+    u32* assetBoundingBox;
+    Collider* collider;
+    HitAssetCollider* assetCollider;
+    ColliderTriangle* triangle;
+    s32* trianglePacked;
+    s16 numTriangles;
+    s32 i,j;
+    f32 e13_y, e21_z, e13_z, e21_y, e21_x, e13_x, normalX, normalY, normalZ, coeff;
+
+    assetCollisionData = NULL;
+    collisionData = NULL;
+
+    map = get_current_map_header();
+
+    switch (idx) {
+        case 0:
+            collisionOffset = map->hitAssetCollisionOffset;
+            if (collisionOffset == 0)
+                return;
+
+            assetCollisionData = (HitFileHeader*)((void*)hit + collisionOffset);
+            collisionData = &gCollisionData;
+            break;
+
+        case 1:
+            collisionOffset = map->hitAssetZoneOffset;
+            if (collisionOffset == 0)
+                return;
+
+            assetCollisionData = (HitFileHeader*)((void*)hit + collisionOffset);
+            collisionData = &gZoneCollisionData;
+            break;
+    }
+
+    assetBoundingBox = (u32*)((void*)hit + assetCollisionData->boundingBoxesOffset);;
+    collisionData->aabbs = collision_heap_malloc(assetCollisionData->boundingBoxesDataSize * 4);
+    for (i = 0, boundingBox = (u32*)(collisionData->aabbs); i < assetCollisionData->boundingBoxesDataSize;
+        assetBoundingBox++, boundingBox++, i++) {
+        *boundingBox = *assetBoundingBox;
+    }
+
+    assetVertices = (Vec3s*)((void*)hit + assetCollisionData->verticesOffset);
+    collisionData->vertices = collision_heap_malloc(assetCollisionData->numVertices * sizeof(Vec3f));
+    for (i = 0, vertices = collisionData->vertices; i < assetCollisionData->numVertices;
+        vertices++, assetVertices++, i++) {
+        vertices->x = assetVertices->x;
+        vertices->y = assetVertices->y;
+        vertices->z = assetVertices->z;
+    }
+
+    assetCollider = (HitAssetCollider*)((void*)hit + assetCollisionData->collidersOffset);
+    collider = collisionData->colliderList = collision_heap_malloc(assetCollisionData->numColliders * sizeof(Collider));
+    collisionData->numColliders = assetCollisionData->numColliders;
+    for (i = 0; i < assetCollisionData->numColliders; assetCollider++, collider++, i++) {
+        collider->flags = 0;
+        collider->nextSibling = assetCollider->nextSibling;
+        collider->firstChild = assetCollider->firstChild;
+        collider->numTriangles = assetCollider->numTriangles;
+
+        numTriangles = collider->numTriangles;
+
+        if (numTriangles) {
+            collider->triangleTable = triangle = collision_heap_malloc(assetCollider->numTriangles * sizeof(ColliderTriangle));
+
+            if (assetCollider->boundingBoxOffset < 0) {
+                collider->aabb = NULL;
+            } else {
+                collider->aabb = (ColliderBoundingBox*)((u32*)(collisionData->aabbs) + assetCollider->boundingBoxOffset);
+
+                if (idx == 0) {
+                    collider->aabb->min.x -= 1;
+                    collider->aabb->min.y -= 1;
+                    collider->aabb->min.z -= 1;
+                    collider->aabb->max.x += 1;
+                    collider->aabb->max.y += 1;
+                    collider->aabb->max.z += 1;
+                    collider->flags = collider->aabb->flagsForCollider;
+                }
+            }
+
+            trianglePacked = (s32*)((void*)hit + assetCollider->trianglesOffset);
+
+            for (j = 0; j < assetCollider->numTriangles; trianglePacked++, triangle++, j++) {
+                Vec3f* v1 = triangle->v1 = &collisionData->vertices[(*trianglePacked) & 0x3FF];
+                Vec3f* v2 = triangle->v2 = &collisionData->vertices[(*trianglePacked >> 10) & 0x3FF];
+                Vec3f* v3 = triangle->v3 = &collisionData->vertices[(*trianglePacked >> 20) & 0x3FF];
+                triangle->oneSided = (*trianglePacked >> 30) & 1;
+
+                triangle->e13.x = v3->x - v1->x;
+                triangle->e13.y = v3->y - v1->y;
+                triangle->e13.z = v3->z - v1->z;
+                triangle->e21.x = v1->x - v2->x;
+                triangle->e21.y = v1->y - v2->y;
+                triangle->e21.z = v1->z - v2->z;
+                triangle->e32.x = v2->x - v3->x;
+                triangle->e32.y = v2->y - v3->y;
+                triangle->e32.z = v2->z - v3->z;
+
+                e13_x = triangle->e13.x;
+                e13_y = triangle->e13.y;
+                e13_z = triangle->e13.z;
+                e21_x = triangle->e21.x;
+                e21_y = triangle->e21.y;
+                e21_z = triangle->e21.z;
+
+                // vector product
+                normalX = e13_y * e21_z - e13_z * e21_y;
+                normalY = e13_z * e21_x - e13_x * e21_z;
+                normalZ = e13_x * e21_y - e13_y * e21_x;
+                coeff  = SQ(normalX) + SQ(normalY) + SQ(normalZ);
+
+                if (coeff != 0)
+                    coeff = 1.0f / sqrtf(coeff);
+                else
+                    coeff = 0.0f;
+
+                triangle->normal.x = normalX * coeff;
+                triangle->normal.y = normalY * coeff;
+                triangle->normal.z = normalZ * coeff;
+            }
+        }
+    }
+}
+
+void parent_collider_to_model(s16 colliderID, s16 modelIndex) {
+    Collider* collider;
+    ColliderTriangle* triangle;
+    s32 i;
+    Vec3f** vertexBuffer;
+    Vec3f** vertexPtr;
+    s32 vertexBufferSize;
+    Vec3f* vertexTable;
+    Vec3f* vertex;
+
+    collider = &gCollisionData.colliderList[colliderID];
+    collider->parentModelIndex = modelIndex;
+    collider->flags |= 0x80000000;
+
+    vertexBuffer = collision_heap_malloc(collider->numTriangles * 0xC);
+    vertexBufferSize = 0;
+    vertexPtr = vertexBuffer;
+
+    for (i = 0, triangle = collider->triangleTable; i < collider->numTriangles; i++, triangle++) {
+        _add_hit_vert_to_buffer(vertexBuffer, triangle->v1, &vertexBufferSize);
+        _add_hit_vert_to_buffer(vertexBuffer, triangle->v2, &vertexBufferSize);
+        _add_hit_vert_to_buffer(vertexBuffer, triangle->v3, &vertexBufferSize);
+    }
+
+    collider->numVertices = vertexBufferSize;
+    collider->vertexTable = collision_heap_malloc(vertexBufferSize * 0x18);
+    for (i = 0, vertexTable = collider->vertexTable; i < vertexBufferSize; vertexPtr++, vertexTable += 2, i++) {
+        vertex = *vertexPtr;
+        vertexTable->x = vertexTable[1].x = vertex->x;
+        vertexTable->y = vertexTable[1].y = vertex->y;
+        vertexTable->z = vertexTable[1].z = vertex->z;
+    }
+
+    vertexTable = collider->vertexTable;
+    for (i = 0, triangle = collider->triangleTable; i < collider->numTriangles; triangle++, i++) {
+        triangle->v1 = &vertexTable[_get_hit_vert_index_from_buffer(vertexBuffer, triangle->v1, &vertexBufferSize) * 2];
+        triangle->v2 = &vertexTable[_get_hit_vert_index_from_buffer(vertexBuffer, triangle->v2, &vertexBufferSize) * 2];
+        triangle->v3 = &vertexTable[_get_hit_vert_index_from_buffer(vertexBuffer, triangle->v3, &vertexBufferSize) * 2];
+    }
+
+    collision_heap_free(vertexBuffer);
+}
+
+void _add_hit_vert_to_buffer(Vec3f** buf, Vec3f* vert, s32* bufSize) {
+    s32 i;
+
+    for (i = 0; i < *bufSize; i++)
+        if (buf[i] == vert)
+            break;
+
+    if (i == *bufSize) {
+        buf[i] = vert;
+        (*bufSize)++;
+    }
+}
+
+s32 _get_hit_vert_index_from_buffer(Vec3f** buffer, Vec3f* vert, s32* bufferSize) {
+    s32 i;
+
+    for (i = 0; i < *bufferSize; i++) {
+        if (*buffer == vert) {
+            break;
+        }
+        buffer++;
+    }
+
+    return i;
+}
+
+void update_collider_transform(s16 colliderID) {
+    Collider* collider;
+    struct Model* model;
+    Matrix4f matrix;
+    s32 i;
+    Vec3f* vertexTable;
+    f32 min_x, min_y, min_z, max_x, max_y, max_z;
+    ColliderTriangle* triangle;
+    f32 e13_y, e21_z, e13_z, e21_y, e21_x, e13_x, normalX, normalY, normalZ, coeff;
+
+    collider = &gCollisionData.colliderList[colliderID];
+    model = get_model_from_list_index(collider->parentModelIndex);
+
+    if (!model->currentMatrix) {
+        copy_matrix(model->transformMatrix, matrix);
+    } else {
+        guMtxL2F(matrix, (Mtx*)model->currentMatrix);
+        guMtxCatF(model->transformMatrix, matrix, matrix);
+    }
+
+    triangle = collider->triangleTable;
+    vertexTable = collider->vertexTable;
+
+    min_x = min_y = min_z = 999999.9f;
+    max_x = max_y = max_z = -999999.9f;
+
+    for (i = 0; i < collider->numVertices; vertexTable += 2, i++) {
+        guMtxXFMF(matrix, vertexTable[1].x, vertexTable[1].y, vertexTable[1].z, &vertexTable[0].x, &vertexTable[0].y, &vertexTable[0].z);
+
+        if (vertexTable[0].x < min_x)
+            min_x = vertexTable[0].x;
+        if (vertexTable[0].x > max_x)
+            max_x = vertexTable[0].x;
+        if (vertexTable[0].y < min_y)
+            min_y = vertexTable[0].y;
+        if (vertexTable[0].y > max_y)
+            max_y = vertexTable[0].y;
+        if (vertexTable[0].z < min_z)
+            min_z = vertexTable[0].z;
+        if (vertexTable[0].z > max_z)
+            max_z = vertexTable[0].z;
+    }
+
+    collider->aabb->min.x = min_x;
+    collider->aabb->min.y = min_y;
+    collider->aabb->min.z = min_z;
+    collider->aabb->max.x = max_x;
+    collider->aabb->max.y = max_y;
+    collider->aabb->max.z = max_z;
+
+    for (i = 0; i < collider->numTriangles; triangle++, i++) {
+        Vec3f* v1 = triangle->v1;
+        Vec3f* v2 = triangle->v2;
+        Vec3f* v3 = triangle->v3;
+
+        triangle->e13.x = v3->x - v1->x;
+        triangle->e13.y = v3->y - v1->y;
+        triangle->e13.z = v3->z - v1->z;
+        triangle->e21.x = v1->x - v2->x;
+        triangle->e21.y = v1->y - v2->y;
+        triangle->e21.z = v1->z - v2->z;
+        triangle->e32.x = v2->x - v3->x;
+        triangle->e32.y = v2->y - v3->y;
+        triangle->e32.z = v2->z - v3->z;
+
+        e13_x = triangle->e13.x;
+        e13_y = triangle->e13.y;
+        e13_z = triangle->e13.z;
+        e21_x = triangle->e21.x;
+        e21_y = triangle->e21.y;
+        e21_z = triangle->e21.z;
+
+        // vector product
+        normalX = e13_y * e21_z - e13_z * e21_y;
+        normalY = e13_z * e21_x - e13_x * e21_z;
+        normalZ = e13_x * e21_y - e13_y * e21_x;
+        coeff  = SQ(normalX) + SQ(normalY) + SQ(normalZ);
+
+        if (coeff != 0)
+            coeff = 1.0f / sqrtf(coeff);
+        else
+            coeff = 0.0f;
+
+        triangle->normal.x = normalX * coeff;
+        triangle->normal.y = normalY * coeff;
+        triangle->normal.z = normalZ * coeff;
+    }
+}
+
+s32 get_collider_type_by_id(s32 colliderID) {
+    if (colliderID & 0x4000) {
+        return 0;
+    } else {
+        return gCollisionData.colliderList[colliderID].flags;
+    }
+}
+
+void get_flat_collider_normal(s32 colliderID, f32* x, f32* y, f32* z) {
+    ColliderTriangle* triangle = &gCollisionData.colliderList[colliderID].triangleTable[0];
+
+    *x = triangle->normal.x;
+    *y = triangle->normal.y;
+    *z = triangle->normal.z;
+}
+
+void get_collider_center(s32 colliderID, f32* x, f32* y, f32* z) {
+    ColliderBoundingBox* aabb = gCollisionData.colliderList[colliderID].aabb;
+
+    *x = (aabb->min.x + aabb->max.x) * 0.5f;
+    *y = (aabb->min.y + aabb->max.y) * 0.5f;
+    *z = (aabb->min.z + aabb->max.z) * 0.5f;
+}
+
+s32 test_ray_triangle_general(ColliderTriangle* triangle, Vec3f* vertices) {
+    f32 distToTrianglePlane;
+    f32 cosAngle;
+    Vec3f* v1;
+    Vec3f* v2;
+    Vec3f* v3;
+
+    if (triangle->normal.x == 0 &&
+        triangle->normal.y == 0 &&
+        triangle->normal.z == 0)
+        return FALSE;
+
+    v1 = triangle->v1;
+    v2 = triangle->v2;
+    v3 = triangle->v3;
+
+    distToTrianglePlane = triangle->normal.x * (gCollisionRayStartX - v1->x) +
+                          triangle->normal.y * (gCollisionRayStartY - v1->y) +
+                          triangle->normal.z * (gCollisionRayStartZ - v1->z);
+
+    if (triangle->oneSided) {
+        if (distToTrianglePlane < 0)
+            return FALSE;
+
+        if (triangle->normal.x * gCollisionRayDirX + triangle->normal.y * gCollisionRayDirY + triangle->normal.z * gCollisionRayDirZ >= 0)
+            return FALSE;
+
+        if ((gCollisionRayStartX - v1->x) * (triangle->e13.z * gCollisionRayDirY - triangle->e13.y * gCollisionRayDirZ) +
+            (gCollisionRayStartY - v1->y) * (triangle->e13.x * gCollisionRayDirZ - triangle->e13.z * gCollisionRayDirX) +
+            (gCollisionRayStartZ - v1->z) * (triangle->e13.y * gCollisionRayDirX - triangle->e13.x * gCollisionRayDirY) < 0)
+            return FALSE;
+
+        if ((gCollisionRayStartX - v2->x) * (triangle->e21.z * gCollisionRayDirY - triangle->e21.y * gCollisionRayDirZ) +
+            (gCollisionRayStartY - v2->y) * (triangle->e21.x * gCollisionRayDirZ - triangle->e21.z * gCollisionRayDirX) +
+            (gCollisionRayStartZ - v2->z) * (triangle->e21.y * gCollisionRayDirX - triangle->e21.x * gCollisionRayDirY) < 0)
+            return FALSE;
+
+        if ((gCollisionRayStartX - v3->x) * (triangle->e32.z * gCollisionRayDirY - triangle->e32.y * gCollisionRayDirZ) +
+            (gCollisionRayStartY - v3->y) * (triangle->e32.x * gCollisionRayDirZ - triangle->e32.z * gCollisionRayDirX) +
+            (gCollisionRayStartZ - v3->z) * (triangle->e32.y * gCollisionRayDirX - triangle->e32.x * gCollisionRayDirY) < 0)
+            return FALSE;
+    } else {
+        if ((triangle->normal.x * gCollisionRayDirX + triangle->normal.y * gCollisionRayDirY + triangle->normal.z * gCollisionRayDirZ) * distToTrianglePlane >= 0)
+            return FALSE;
+
+        if (((gCollisionRayStartX - v1->x) * (triangle->e13.z * gCollisionRayDirY - triangle->e13.y * gCollisionRayDirZ) +
+             (gCollisionRayStartY - v1->y) * (triangle->e13.x * gCollisionRayDirZ - triangle->e13.z * gCollisionRayDirX) +
+             (gCollisionRayStartZ - v1->z) * (triangle->e13.y * gCollisionRayDirX - triangle->e13.x * gCollisionRayDirY)) * distToTrianglePlane < 0)
+            return FALSE;
+
+        if (((gCollisionRayStartX - v2->x) * (triangle->e21.z * gCollisionRayDirY - triangle->e21.y * gCollisionRayDirZ) +
+             (gCollisionRayStartY - v2->y) * (triangle->e21.x * gCollisionRayDirZ - triangle->e21.z * gCollisionRayDirX) +
+             (gCollisionRayStartZ - v2->z) * (triangle->e21.y * gCollisionRayDirX - triangle->e21.x * gCollisionRayDirY)) * distToTrianglePlane < 0)
+            return FALSE;
+
+        if (((gCollisionRayStartX - v3->x) * (triangle->e32.z * gCollisionRayDirY - triangle->e32.y * gCollisionRayDirZ) +
+             (gCollisionRayStartY - v3->y) * (triangle->e32.x * gCollisionRayDirZ - triangle->e32.z * gCollisionRayDirX) +
+             (gCollisionRayStartZ - v3->z) * (triangle->e32.y * gCollisionRayDirX - triangle->e32.x * gCollisionRayDirY)) * distToTrianglePlane < 0)
+            return FALSE;
+    }
+
+    cosAngle = triangle->normal.x * gCollisionRayDirX + triangle->normal.y * gCollisionRayDirY + triangle->normal.z * gCollisionRayDirZ;
+    if (gCollisionRayLength >= 0 && gCollisionRayLength <= -distToTrianglePlane / cosAngle)
+        return FALSE;
+
+    gCollisionRayLength = -distToTrianglePlane  / cosAngle;
+
+    gCollisionPointX = gCollisionRayStartX + gCollisionRayDirX * gCollisionRayLength;
+    gCollisionPointY = gCollisionRayStartY + gCollisionRayDirY * gCollisionRayLength;
+    gCollisionPointZ = gCollisionRayStartZ + gCollisionRayDirZ * gCollisionRayLength;
+
+    gCollisionNormalX = triangle->normal.x;
+    gCollisionNormalY = triangle->normal.y;
+    gCollisionNormalZ = triangle->normal.z;
+
+    return TRUE;
+}
+
+s32 test_ray_triangle_down(ColliderTriangle* triangle, Vec3f* vertices) {
+    f32 distToTrianglePlane, cosAngle;
+    Vec3f* v1;
+    Vec3f* v2;
+    Vec3f* v3;
+
+    if (triangle->normal.x == 0 &&
+        triangle->normal.y == 0 &&
+        triangle->normal.z == 0)
+        return FALSE;
+
+    v1 = triangle->v1;
+    v2 = triangle->v2;
+    v3 = triangle->v3;
+
+    distToTrianglePlane = triangle->normal.x * (gCollisionRayStartX - v1->x) +
+                          triangle->normal.y * (gCollisionRayStartY - v1->y) +
+                          triangle->normal.z * (gCollisionRayStartZ - v1->z);
+
+    if (triangle->oneSided) {
+        if (distToTrianglePlane < 0)
+            return FALSE;
+
+        if (triangle->normal.y <= 0)
+            return FALSE;
+
+        if ((gCollisionRayStartZ - v1->z) * triangle->e13.x - (gCollisionRayStartX - v1->x) * triangle->e13.z < 0)
+            return FALSE;
+
+        if ((gCollisionRayStartZ - v2->z) * triangle->e21.x - (gCollisionRayStartX - v2->x) * triangle->e21.z < 0)
+            return FALSE;
+
+        if ((gCollisionRayStartZ - v3->z) * triangle->e32.x - (gCollisionRayStartX - v3->x) * triangle->e32.z < 0)
+            return FALSE;
+    } else {
+        if (triangle->normal.y * distToTrianglePlane <= 0)
+            return FALSE;
+
+        if (((gCollisionRayStartZ - v1->z) * triangle->e13.x - (gCollisionRayStartX - v1->x) * triangle->e13.z) * distToTrianglePlane < 0)
+            return FALSE;
+
+        if (((gCollisionRayStartZ - v2->z) * triangle->e21.x - (gCollisionRayStartX - v2->x) * triangle->e21.z) * distToTrianglePlane < 0)
+            return FALSE;
+
+        if (((gCollisionRayStartZ - v3->z) * triangle->e32.x - (gCollisionRayStartX - v3->x) * triangle->e32.z) * distToTrianglePlane < 0)
+            return FALSE;
+    }
+
+    cosAngle = -triangle->normal.y;
+    if (gCollisionRayLength >= 0 && gCollisionRayLength <= -distToTrianglePlane / cosAngle)
+        return FALSE;
+
+    gCollisionRayLength = -distToTrianglePlane  / cosAngle;
+
+    gCollisionPointX = gCollisionRayStartX;
+    gCollisionPointY = gCollisionRayStartY - gCollisionRayLength;
+    gCollisionPointZ = gCollisionRayStartZ;
+
+    gCollisionNormalX = triangle->normal.x;
+    gCollisionNormalY = triangle->normal.y;
+    gCollisionNormalZ = triangle->normal.z;
+
+    return TRUE;
+}
+
+s32 test_ray_triangle_horizontal(ColliderTriangle* triangle, Vec3f *vertices) {
+    f32 distToTrianglePlane, cosAngle;
+    Vec3f* v1;
+    Vec3f* v2;
+    Vec3f* v3;
+
+    if (triangle->normal.x == 0 &&
+        triangle->normal.y == 0 &&
+        triangle->normal.z == 0)
+        return FALSE;
+
+    v1 = triangle->v1;
+    v2 = triangle->v2;
+    v3 = triangle->v3;
+
+    distToTrianglePlane = triangle->normal.x * (gCollisionRayStartX - v1->x) +
+                          triangle->normal.y * (gCollisionRayStartY - v1->y) +
+                          triangle->normal.z * (gCollisionRayStartZ - v1->z);
+
+    if (triangle->oneSided) {
+        if (distToTrianglePlane < 0)
+            return FALSE;
+
+        if (triangle->normal.x * gCollisionRayDirX + triangle->normal.z * gCollisionRayDirZ >= 0)
+            return FALSE;
+
+        if ((gCollisionRayStartX - v1->x) * (-triangle->e13.y * gCollisionRayDirZ) +
+            (gCollisionRayStartY - v1->y) * (triangle->e13.x * gCollisionRayDirZ - triangle->e13.z * gCollisionRayDirX) +
+            (gCollisionRayStartZ - v1->z) * (triangle->e13.y * gCollisionRayDirX) < 0)
+            return FALSE;
+
+        if ((gCollisionRayStartX - v2->x) * (-triangle->e21.y * gCollisionRayDirZ) +
+            (gCollisionRayStartY - v2->y) * (triangle->e21.x * gCollisionRayDirZ - triangle->e21.z * gCollisionRayDirX) +
+            (gCollisionRayStartZ - v2->z) * (triangle->e21.y * gCollisionRayDirX) < 0)
+            return FALSE;
+
+        if ((gCollisionRayStartX - v3->x) * (-triangle->e32.y * gCollisionRayDirZ) +
+            (gCollisionRayStartY - v3->y) * (triangle->e32.x * gCollisionRayDirZ - triangle->e32.z * gCollisionRayDirX) +
+            (gCollisionRayStartZ - v3->z) * (triangle->e32.y * gCollisionRayDirX) < 0)
+            return FALSE;
+    } else {
+        if ((triangle->normal.x * gCollisionRayDirX + triangle->normal.z * gCollisionRayDirZ) * distToTrianglePlane >= 0)
+            return FALSE;
+
+        if (((gCollisionRayStartX - v1->x) * (-triangle->e13.y * gCollisionRayDirZ) +
+            (gCollisionRayStartY - v1->y) * (triangle->e13.x * gCollisionRayDirZ - triangle->e13.z * gCollisionRayDirX) +
+            (gCollisionRayStartZ - v1->z) * (triangle->e13.y * gCollisionRayDirX)) * distToTrianglePlane < 0)
+            return FALSE;
+
+        if (((gCollisionRayStartX - v2->x) * (-triangle->e21.y * gCollisionRayDirZ) +
+            (gCollisionRayStartY - v2->y) * (triangle->e21.x * gCollisionRayDirZ - triangle->e21.z * gCollisionRayDirX) +
+            (gCollisionRayStartZ - v2->z) * (triangle->e21.y * gCollisionRayDirX)) * distToTrianglePlane < 0)
+            return FALSE;
+
+        if (((gCollisionRayStartX - v3->x) * (-triangle->e32.y * gCollisionRayDirZ) +
+            (gCollisionRayStartY - v3->y) * (triangle->e32.x * gCollisionRayDirZ - triangle->e32.z * gCollisionRayDirX) +
+            (gCollisionRayStartZ - v3->z) * (triangle->e32.y * gCollisionRayDirX)) * distToTrianglePlane < 0)
+            return FALSE;
+    }
+
+    cosAngle = triangle->normal.x * gCollisionRayDirX + triangle->normal.z * gCollisionRayDirZ;
+    if (gCollisionRayLength >= 0 && gCollisionRayLength <= -distToTrianglePlane / cosAngle)
+        return FALSE;
+
+    gCollisionRayLength = -distToTrianglePlane  / cosAngle;
+
+    gCollisionPointX = gCollisionRayStartX + gCollisionRayDirX * gCollisionRayLength;
+    gCollisionPointY = gCollisionRayStartY;
+    gCollisionPointZ = gCollisionRayStartZ + gCollisionRayDirZ * gCollisionRayLength;
+
+    gCollisionNormalX = triangle->normal.x;
+    gCollisionNormalY = triangle->normal.y;
+    gCollisionNormalZ = triangle->normal.z;
+
+    return TRUE;
+}
+
+s32 test_ray_colliders(s32 ignoreFlags, f32 startX, f32 startY, f32 startZ, f32 dirX, f32 dirY, f32 dirZ,
+                       f32* hitX, f32* hitY, f32* hitZ, f32* hitDepth, f32* hitNx, f32* hitNy, f32* hitNz) {
+    Collider* collider;
+    CollisionData* collisionData;
+    ColliderTriangle* triangle;
+    s32 i, j;
+    s32 colliderID;
+    f32 min_x, min_y, min_z, max_x, max_y, max_z;
+
+    if (dirX == 0 && dirY == 0 && dirZ == 0)
+        return 0;
+
+    collisionData = &gCollisionData;
+    gCollisionRayDirX = dirX;
+    gCollisionRayDirY = dirY;
+    gCollisionRayDirZ = dirZ;
+    gCollisionRayStartX = startX;
+    gCollisionRayStartY = startY;
+    gCollisionRayStartZ = startZ;
+    gCollisionRayLength = *hitDepth;
+    colliderID = -1;
+
+    if (dirX < 0) {
+        min_x = startX + dirX * gCollisionRayLength;
+        max_x = startX;
+    } else {
+        min_x = startX;
+        max_x = startX + dirX * gCollisionRayLength;
+    }
+
+    if (dirY < 0) {
+        min_y = startY + dirY * gCollisionRayLength;
+        max_y = startY;
+    } else {
+        min_y = startY;
+        max_y = startY + dirY * gCollisionRayLength;
+    }
+
+    if (dirZ < 0) {
+        min_z = startZ + dirZ * gCollisionRayLength;
+        max_z = startZ;
+    } else {
+        min_z = startZ;
+        max_z = startZ + dirZ * gCollisionRayLength;
+    }
+
+    for (i = 0; i < collisionData->numColliders; i++) {
+        collider = &collisionData->colliderList[i];
+
+        if ((collider->flags & ignoreFlags) ||
+            collider->numTriangles == 0     ||
+            max_x < collider->aabb->min.x   ||
+            min_x > collider->aabb->max.x   ||
+            max_z < collider->aabb->min.z   ||
+            min_z > collider->aabb->max.z   ||
+            max_y < collider->aabb->min.y   ||
+            min_y > collider->aabb->max.y)
+                continue;
+
+        triangle = collider->triangleTable;
+        if (gCollisionRayDirX == 0 && gCollisionRayDirZ == 0 && gCollisionRayDirY == -1.0) {
+            for (j = 0; j < collider->numTriangles; j++)
+                if (test_ray_triangle_down(triangle++, collisionData->vertices))
+                    colliderID = i;
+        } else if (gCollisionRayDirY == 0) {
+            for (j = 0; j < collider->numTriangles; j++)
+                if (test_ray_triangle_horizontal(triangle++, collisionData->vertices))
+                    colliderID = i;
+        } else {
+            for (j = 0; j < collider->numTriangles; j++)
+                if (test_ray_triangle_general(triangle++, collisionData->vertices))
+                    colliderID = i;
+        }
+    }
+
+    if (colliderID >= 0) {
+        *hitX = gCollisionPointX;
+        *hitY = gCollisionPointY;
+        *hitZ = gCollisionPointZ;
+        *hitDepth = gCollisionRayLength;
+        *hitNx = gCollisionNormalX;
+        *hitNy = gCollisionNormalY;
+        *hitNz = gCollisionNormalZ;
+        return colliderID;
+    } else
+        return colliderID;
+}
+
+s32 test_ray_zones(f32 startX, f32 startY, f32 startZ, f32 dirX, f32 dirY, f32 dirZ,
+                f32* hitX, f32* hitY, f32* hitZ, f32* hitDepth, f32* hitNx, f32* hitNy, f32* hitNz) {
+    Collider* collider;
+    CollisionData* collisionData;
+    ColliderTriangle* triangle;
+    s32 i, j;
+    s32 colliderID;
+
+    collisionData = &gZoneCollisionData;
+    gCollisionRayDirX = dirX;
+    gCollisionRayDirY = dirY;
+    gCollisionRayDirZ = dirZ;
+    gCollisionRayStartX = startX;
+    gCollisionRayStartY = startY;
+    gCollisionRayStartZ = startZ;
+    gCollisionRayLength = *hitDepth;
+    colliderID = -1;
+
+    for (i = 0; i < collisionData->numColliders; i++) {
+        collider = &collisionData->colliderList[i];
+
+        if (collider->flags & 0x10000)
+            continue;
+
+        if (collider->numTriangles == 0 || collider->aabb == NULL)
+            continue;
+
+        triangle = collider->triangleTable;
+        for (j = 0; j < collider->numTriangles; j++)
+            if (test_ray_triangle_down(triangle++, collisionData->vertices))
+                colliderID = i;
+    }
+
+    if (colliderID >= 0) {
+        *hitX = gCollisionPointX;
+        *hitY = gCollisionPointY;
+        *hitZ = gCollisionPointZ;
+        *hitDepth = gCollisionRayLength;
+        *hitNx = gCollisionNormalX;
+        *hitNy = gCollisionNormalY;
+        *hitNz = gCollisionNormalZ;
+        return colliderID;
+    } else
+        return colliderID;
+}
+
+f32 test_ray_collider_horizontal(s32 ignoreFlags, s32 colliderID, f32 x, f32 y, f32 z, f32 length, f32 yaw) {
+    CollisionData* collisionData = &gCollisionData;
+    f32 cosTheta;
+    f32 sinTheta;
+    Collider* collider;
+    ColliderTriangle* triangleTable;
+    s32 i;
+    f32 ret;
+
+    sin_cos_rad(yaw * TAU / 360.0f, &sinTheta, &cosTheta);
+    collider = &collisionData->colliderList[colliderID];
+
+    gCollisionRayDirY = 0;
+    gCollisionRayStartX = x;
+    gCollisionRayStartY = y;
+    gCollisionRayStartZ = z;
+    gCollisionRayLength = length;
+    gCollisionRayDirX = sinTheta;
+    gCollisionRayDirZ = -cosTheta;
+    ret = -1.0f;
+
+    if (!(collider->flags & ignoreFlags) && collider->numTriangles != 0) {
+        triangleTable = collider->triangleTable;
+
+        for (i = 0; i < collider->numTriangles; i++)
+            if (test_ray_triangle_horizontal(triangleTable++, collisionData->vertices))
+                ret = gCollisionRayLength;
+    }
+
+    return ret;
+}
+
+s32 test_ray_entities(f32 startX, f32 startY, f32 startZ, f32 dirX, f32 dirY, f32 dirZ,
+                      f32* hitX, f32* hitY, f32* hitZ, f32* hitDepth, f32* hitNx, f32* hitNy, f32* hitNz) {
+    f32 hitDepthDown, hitDepthHoriz;
+    s32 type;
+    s32 i, j;
+    Entity* entity;
+    Matrix4f tempMatrix1;
+    Matrix4f tempMatrix2;
+    Vec3f boxVertices[8];
+    ColliderTriangle entityTriangle;
+    s32 entityIndex;
+    f32 h;
+    f32 aabbX, aabbZ;
+    s32 hasCollision;
+    f32 dist, dist2;
+    ColliderTriangle *triangle = &entityTriangle;
+
+    entityIndex = -1;
+    type = 0;
+    hitDepthDown = hitDepthHoriz = *hitDepth;
+
+    if (dirX == 0 && dirZ == 0 && dirY < 0) {
+        hitDepthHoriz = 0;
+        type = 1;
+    } else if (dirY == 0) {
+        hitDepthDown = 0;
+        type = 2;
+    }
+
+    gCollisionRayLength = -1;
+    triangle->oneSided = TRUE;
+    for (i = 0; i < MAX_ENTITIES; i++) {
+        entity = get_entity_by_index(i);
+
+        if (entity == NULL || (entity->flags & 0x40000020))
+            continue;
+
+        dist = hitDepthHoriz + entity->effectiveSize;
+        if (startX > entity->position.x + dist ||
+            startX < entity->position.x - dist)
+            continue;
+
+        if (startZ > entity->position.z + dist ||
+            startZ < entity->position.z - dist)
+            continue;
+
+        switch (type) {
+        case 0:
+        case 1:
+            dist = entity->position.y;
+            dist2 = hitDepthDown + entity->effectiveSize * 2;
+            if (dist + dist2 < startY || startY < dist - dist2)
+                continue;
+            break;
+        case 2:
+            dist = entity->position.y;
+            dist2 = entity->effectiveSize * 2;
+            if (dist + dist2 < startY || startY < dist - dist2)
+                continue;
+            break;
+        }
+
+        aabbX = entity->aabb.x / 2;
+        aabbZ = entity->aabb.z / 2;
+
+        boxVertices[1].x = boxVertices[2].x = boxVertices[5].x = boxVertices[6].x = -aabbX;
+        boxVertices[0].x = boxVertices[3].x = boxVertices[4].x = boxVertices[7].x = aabbX;
+        boxVertices[0].y = boxVertices[1].y = boxVertices[2].y = boxVertices[3].y = 0;
+        boxVertices[4].y = boxVertices[5].y = boxVertices[6].y = boxVertices[7].y = entity->aabb.y;
+        boxVertices[0].z = boxVertices[1].z = boxVertices[4].z = boxVertices[5].z = aabbZ;
+        boxVertices[2].z = boxVertices[3].z = boxVertices[6].z = boxVertices[7].z = -aabbZ;
+
+        guMtxXFMF(entity->inverseTransformMatrix, dirX, dirY, dirZ, &gCollisionRayDirX, &gCollisionRayDirY, &gCollisionRayDirZ);
+        guMtxXFMF(entity->inverseTransformMatrix, startX - entity->position.x, startY - entity->position.y,
+                  startZ - entity->position.z, &gCollisionRayStartX, &gCollisionRayStartY, &gCollisionRayStartZ);
+
+        for (j = 0; j < 12; j++) {
+            Vec3f* v1 = triangle->v1 = &boxVertices[gEntityColliderFaces[j].i1];
+            Vec3f* v2 = triangle->v2 = &boxVertices[gEntityColliderFaces[j].i2];
+            Vec3f* v3 = triangle->v3 = &boxVertices[gEntityColliderFaces[j].i3];
+            triangle->e13.x = v3->x - v1->x;
+            triangle->e13.y = v3->y - v1->y;
+            triangle->e13.z = v3->z - v1->z;
+            triangle->e21.x = v1->x - v2->x;
+            triangle->e21.y = v1->y - v2->y;
+            triangle->e21.z = v1->z - v2->z;
+            triangle->e32.x = v2->x - v3->x;
+            triangle->e32.y = v2->y - v3->y;
+            triangle->e32.z = v2->z - v3->z;
+            triangle->normal.x = gEntityColliderNormals[j].x;
+            triangle->normal.y = gEntityColliderNormals[j].y;
+            triangle->normal.z = gEntityColliderNormals[j].z;
+
+            if (hasCollision = test_ray_triangle_general(&entityTriangle, boxVertices))
+                break;
+        }
+
+        if (hasCollision && gCollisionRayLength < *hitDepth) {
+            entityIndex = i;
+            *hitDepth = gCollisionRayLength;
+
+            switch (type) {
+            case 0:
+                hitDepthDown = gCollisionRayLength;
+                hitDepthHoriz = gCollisionRayLength;
+                break;
+            case 1:
+                hitDepthDown = gCollisionRayLength;
+                break;
+            case 2:
+                hitDepthHoriz = gCollisionRayLength;
+                break;
+            }
+
+            guRotateF(tempMatrix1, entity->rotation.x, 1.0f, 0.0f, 0.0f);
+            guRotateF(tempMatrix2, entity->rotation.z, 0.0f, 0.0f, 1.0f);
+            guMtxCatF(tempMatrix1, tempMatrix2, tempMatrix1);
+            guRotateF(tempMatrix2, entity->rotation.y, 0.0f, 1.0f, 0.0f);
+            guMtxCatF(tempMatrix1, tempMatrix2, tempMatrix1);
+            guTranslateF(tempMatrix2, entity->position.x, entity->position.y, entity->position.z);
+            guMtxCatF(tempMatrix1, tempMatrix2, tempMatrix1);
+            guMtxXFMF(tempMatrix1, gCollisionPointX, gCollisionPointY, gCollisionPointZ, hitX, hitY, hitZ);
+
+            h = 1.0f / sqrtf(SQ(gCollisionNormalX) + SQ(gCollisionNormalY) + SQ(gCollisionNormalZ));
+            *hitNx = gCollisionNormalX * h;
+            *hitNy = gCollisionNormalY * h;
+            *hitNz = gCollisionNormalZ * h;
+        }
+    }
+
+    return entityIndex;
+}
+
+ApiStatus func_8005DB00(Evt* script, s32 isInitialCall) {
+    Npc* npc;
+    f32 targetDir, npcYaw;
+    PlayerStatus* playerStatus;
+    PartnerActionStatus* partnerStatus;
+
+    npc = get_npc_unsafe(script->owner1.enemy->npcID);
+    playerStatus = &gPlayerStatus;
+    partnerStatus = &gPartnerActionStatus;
+
+    if (isInitialCall)
+        script->functionTemp[0] = 0;
+
+    switch(script->functionTemp[0]) {
+    case 0:
+        npc->planarFlyDist = evt_get_float_variable(script, LW(0));
+        npc->duration = evt_get_variable(script, LW(1));
+        script->functionTemp[1] = evt_get_variable(script, LW(2));
+        script->functionTemp[2] = evt_get_variable(script, LW(3)) / 2;
+        npc->currentAnim.w = script->varTable[10];
+        script->functionTemp[0] = 1;
+        break;
+    case 1:
+        if (partnerStatus->actionState.b[3] != 9) {
+            if (npc->duration != 0 && npc->duration != script->functionTemp[0])
+                return ApiStatus_BLOCK;
+
+            if (npc->duration == 0) {
+                if (sqrtf(SQ((playerStatus->position.x - npc->pos.x)) +
+                          SQ((playerStatus->position.y - npc->pos.y)) +
+                          SQ((playerStatus->position.z - npc->pos.z))) <= npc->planarFlyDist) {
+                    targetDir = atan2(npc->pos.x, npc->pos.z, playerStatus->position.x, playerStatus->position.z);
+                    npcYaw = script->functionTemp[1] == -1 ? npc->yaw : script->functionTemp[1];
+
+                    if (fabsf(get_clamped_angle_diff(npcYaw, targetDir)) < script->functionTemp[2]) {
+                        script->varTable[0] = 1;
+                        return ApiStatus_DONE2;
+                    }
+                }
+            } else {
+                if (dist2D(npc->pos.x, npc->pos.z, playerStatus->position.x, playerStatus->position.z) <= npc->planarFlyDist) {
+                    targetDir = atan2(npc->pos.x, npc->pos.z, playerStatus->position.x, playerStatus->position.z);
+                    npcYaw = script->functionTemp[1] == -1 ? npc->yaw : script->functionTemp[1];
+
+                    if (fabsf(get_clamped_angle_diff(npcYaw, targetDir)) < script->functionTemp[2]) {
+                        script->varTable[0] = 1;
+                        return ApiStatus_DONE2;
+                    }
+                }
+            }
+        }
+        break;
+    }
+
+    return ApiStatus_BLOCK;
+}
+
+ApiStatus func_8005DD54(Evt* script, s32 isInitialCall) {
+    f32 angle = clamp_angle(script->varTable[0]);
+
+    script->varTable[0] = angle;
+    if (angle >= 180.0f) {
+        angle -= 180.0f;
+    }
+    if (angle >= 90.0f) {
+        angle = 180.0f - angle;
+    }
+    script->varTable[2] = (s32) (((90.0f - angle) * 95.0f) / 90.0f) + 160;
+    return ApiStatus_DONE2;
+}
+
+s32 func_8005DDF0(void) {
+    return ~gCurrentEncounter.unk_08 != 0;
+}
diff --git a/src/os/nusys/nuGfxTaskMgr.c b/src/os/nusys/nuGfxTaskMgr.c
index 56e8befc24..bfca12ebe2 100644
--- a/src/os/nusys/nuGfxTaskMgr.c
+++ b/src/os/nusys/nuGfxTaskMgr.c
@@ -15,7 +15,7 @@ extern OSThread GfxTaskMgrThread;
 extern NUScTask nuGfxTask[NU_GFX_TASK_NUM];
 extern s32 D_800DA040;
 extern s32 D_800B91D0;
-extern s32 D_800D91D0;
+extern s32 gZoneCollisionData;
 extern u8 rspbootUcodeBuffer[];
 extern u32 nuGfxCfbCounter;
 extern OSMesgQueue D_800DA47C;
@@ -79,7 +79,7 @@ void nuGfxTaskMgrInit(void) {
         nuGfxTask[i].list.t.dram_stack = &D_800DA040;
         nuGfxTask[i].list.t.dram_stack_size = SP_DRAM_STACK_SIZE8;
         nuGfxTask[i].list.t.output_buff = &D_800B91D0;
-        nuGfxTask[i].list.t.output_buff_size = &D_800D91D0;
+        nuGfxTask[i].list.t.output_buff_size = &gZoneCollisionData;
         nuGfxTask[i].list.t.yield_data_ptr = &nuYieldBuf;
         nuGfxTask[i].list.t.yield_data_size = NU_GFX_YIELD_BUF_SIZE;
     }
diff --git a/src/state_battle.c b/src/state_battle.c
index b70b5f0056..5b243bf715 100644
--- a/src/state_battle.c
+++ b/src/state_battle.c
@@ -67,7 +67,7 @@ void state_step_battle(void) {
             sfx_stop_env_sounds();
             func_8003B1A8();
             gGameStatusPtr->isBattle = TRUE;
-            allocate_hit_tables();
+            backup_map_collision_data();
             func_8002D160();
             func_802B20B4();
             sfx_clear_env_sounds(0);
@@ -186,7 +186,7 @@ void state_step_end_battle(void) {
                 decode_yay0(mapShape, &D_80210000);
                 general_heap_free(mapShape);
                 initialize_collision();
-                load_collision();
+                restore_map_collision_data();
 
                 if (map->dmaStart != NULL) {
                     dma_copy(map->dmaStart, map->dmaEnd, map->dmaDest);
diff --git a/src/state_file_select.c b/src/state_file_select.c
index 9a2aead61a..dd1235d63d 100644
--- a/src/state_file_select.c
+++ b/src/state_file_select.c
@@ -117,7 +117,7 @@ void state_step_language_select(void) {
                     sfx_stop_env_sounds();
                     func_8003B1A8();
                     gGameStatusPtr->isBattle = 2;
-                    allocate_hit_tables();
+                    backup_map_collision_data();
                     battle_heap_create();
                     sfx_clear_env_sounds(0);
                     spr_init_sprites(0);
@@ -290,7 +290,7 @@ void state_step_exit_language_select(void) {
                     decode_yay0(mapShape, &D_80210000);
                     general_heap_free(mapShape);
                     initialize_collision();
-                    load_collision();
+                    restore_map_collision_data();
 
                     if (map->dmaStart != NULL) {
                         dma_copy(map->dmaStart, map->dmaEnd, map->dmaDest);
diff --git a/src/state_pause.c b/src/state_pause.c
index d0a9dcf58c..cc2dbec394 100644
--- a/src/state_pause.c
+++ b/src/state_pause.c
@@ -58,7 +58,7 @@ void state_step_pause(void) {
                     sfx_stop_env_sounds();
                     func_8003B1A8();
                     gGameStatusPtr->isBattle = oldIsBattle;
-                    allocate_hit_tables();
+                    backup_map_collision_data();
                     battle_heap_create();
                     nuContRmbForceStop();
                     sfx_clear_env_sounds(0);
@@ -165,7 +165,7 @@ void state_step_unpause(void) {
                         decode_yay0(assetData, &D_80210000);
                         general_heap_free(assetData);
                         initialize_collision();
-                        load_collision();
+                        restore_map_collision_data();
 
                         if (map->dmaStart != NULL) {
                             dma_copy(map->dmaStart, map->dmaEnd, map->dmaDest);
diff --git a/src/world/world.c b/src/world/world.c
index 249115295a..5448c2dcf5 100644
--- a/src/world/world.c
+++ b/src/world/world.c
@@ -138,7 +138,7 @@ void load_map_by_IDs(s16 areaID, s16 mapID, s16 loadType) {
 
     if (initStatus == 0) {
         initialize_collision();
-        load_hit_asset();
+        load_map_hit_asset();
     }
 
     reset_battle_status();
@@ -274,14 +274,12 @@ s32 get_asset_offset(char* assetName, s32* compressedSize) {
 
 
 // these, along with all the *_maps, almost certainly belong in the next file
-s16 D_8008FF70[] = { 4, 6, 5, 4, 7, 6, 0, 3, 4, 3, 7, 4, 3, 2, 7, 2, 6, 7, 2, 1, 6, 1, 5, 6, 1, 0, 5, 0, 4, 5, 0, 1, 2,
-                     0, 2, 3
-                   };
+s16 gEntityColliderFaces[] = { 4, 6, 5, 4, 7, 6, 0, 3, 4, 3, 7, 4, 3, 2, 7, 2, 6, 7, 2, 1, 6, 1, 5, 6, 1, 0, 5,
+                                 0, 4, 5, 0, 1, 2, 0, 2, 3};
 
-f32 D_8008FFB8[] = { 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f,
-                     0.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, -1.0f,
-                     0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f
-                   };
+f32 gEntityColliderNormals[] = { 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,
+                                       0.0f, -1.0f, 0.0f, 0.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+                                       1.0f, 0.0f, 0.0f, 1.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f};
 
 /// Toad Town
 Map mac_maps[] = {
diff --git a/ver/us/asm/nonmatchings/16F740/btl_state_update_normal_start.s b/ver/us/asm/nonmatchings/16F740/btl_state_update_normal_start.s
index ef4263b414..ff1def4473 100644
--- a/ver/us/asm/nonmatchings/16F740/btl_state_update_normal_start.s
+++ b/ver/us/asm/nonmatchings/16F740/btl_state_update_normal_start.s
@@ -89,7 +89,7 @@ glabel btl_state_update_normal_start
 /* 16FC14 80241334 0040282D */   daddu    $a1, $v0, $zero
 .L80241338:
 /* 16FC18 80241338 8EA40008 */  lw        $a0, 8($s5)
-/* 16FC1C 8024133C 0C016C68 */  jal       load_stage_collision
+/* 16FC1C 8024133C 0C016C68 */  jal       load_battle_hit_asset
 /* 16FC20 80241340 00000000 */   nop
 /* 16FC24 80241344 8EA40014 */  lw        $a0, 0x14($s5)
 /* 16FC28 80241348 10800007 */  beqz      $a0, .L80241368
diff --git a/ver/us/asm/nonmatchings/362a0_len_2f70/allocate_hit_tables.s b/ver/us/asm/nonmatchings/362a0_len_2f70/allocate_hit_tables.s
deleted file mode 100644
index 9c1f7fd101..0000000000
--- a/ver/us/asm/nonmatchings/362a0_len_2f70/allocate_hit_tables.s
+++ /dev/null
@@ -1,65 +0,0 @@
-.set noat      # allow manual use of $at
-.set noreorder # don't insert nops after branches
-
-glabel allocate_hit_tables
-/* 362A0 8005AEA0 27BDFFE8 */  addiu     $sp, $sp, -0x18
-/* 362A4 8005AEA4 AFB00010 */  sw        $s0, 0x10($sp)
-/* 362A8 8005AEA8 3C10800B */  lui       $s0, %hi(gCollisionData)
-/* 362AC 8005AEAC 261042E0 */  addiu     $s0, $s0, %lo(gCollisionData)
-/* 362B0 8005AEB0 AFBF0014 */  sw        $ra, 0x14($sp)
-/* 362B4 8005AEB4 8604000C */  lh        $a0, 0xc($s0)
-/* 362B8 8005AEB8 0C00AB0A */  jal       general_heap_malloc
-/* 362BC 8005AEBC 000420C0 */   sll      $a0, $a0, 3
-/* 362C0 8005AEC0 0040202D */  daddu     $a0, $v0, $zero
-/* 362C4 8005AEC4 8602000C */  lh        $v0, 0xc($s0)
-/* 362C8 8005AEC8 3C01800A */  lui       $at, %hi(D_800A4264)
-/* 362CC 8005AECC AC244264 */  sw        $a0, %lo(D_800A4264)($at)
-/* 362D0 8005AED0 1840000E */  blez      $v0, .L8005AF0C
-/* 362D4 8005AED4 0000282D */   daddu    $a1, $zero, $zero
-/* 362D8 8005AED8 00A0302D */  daddu     $a2, $a1, $zero
-.L8005AEDC:
-/* 362DC 8005AEDC 8E020004 */  lw        $v0, 4($s0)
-/* 362E0 8005AEE0 00461821 */  addu      $v1, $v0, $a2
-/* 362E4 8005AEE4 8C620000 */  lw        $v0, ($v1)
-/* 362E8 8005AEE8 24A50001 */  addiu     $a1, $a1, 1
-/* 362EC 8005AEEC AC820000 */  sw        $v0, ($a0)
-/* 362F0 8005AEF0 94620008 */  lhu       $v0, 8($v1)
-/* 362F4 8005AEF4 24C6001C */  addiu     $a2, $a2, 0x1c
-/* 362F8 8005AEF8 A4820004 */  sh        $v0, 4($a0)
-/* 362FC 8005AEFC 8602000C */  lh        $v0, 0xc($s0)
-/* 36300 8005AF00 00A2102A */  slt       $v0, $a1, $v0
-/* 36304 8005AF04 1440FFF5 */  bnez      $v0, .L8005AEDC
-/* 36308 8005AF08 24840008 */   addiu    $a0, $a0, 8
-.L8005AF0C:
-/* 3630C 8005AF0C 3C10800E */  lui       $s0, %hi(D_800D91D0)
-/* 36310 8005AF10 261091D0 */  addiu     $s0, $s0, %lo(D_800D91D0)
-/* 36314 8005AF14 8604000C */  lh        $a0, 0xc($s0)
-/* 36318 8005AF18 0C00AB0A */  jal       general_heap_malloc
-/* 3631C 8005AF1C 000420C0 */   sll      $a0, $a0, 3
-/* 36320 8005AF20 0040202D */  daddu     $a0, $v0, $zero
-/* 36324 8005AF24 8602000C */  lh        $v0, 0xc($s0)
-/* 36328 8005AF28 3C01800A */  lui       $at, %hi(D_800A4268)
-/* 3632C 8005AF2C AC244268 */  sw        $a0, %lo(D_800A4268)($at)
-/* 36330 8005AF30 1840000E */  blez      $v0, .L8005AF6C
-/* 36334 8005AF34 0000282D */   daddu    $a1, $zero, $zero
-/* 36338 8005AF38 00A0302D */  daddu     $a2, $a1, $zero
-.L8005AF3C:
-/* 3633C 8005AF3C 8E020004 */  lw        $v0, 4($s0)
-/* 36340 8005AF40 00461821 */  addu      $v1, $v0, $a2
-/* 36344 8005AF44 8C620000 */  lw        $v0, ($v1)
-/* 36348 8005AF48 24A50001 */  addiu     $a1, $a1, 1
-/* 3634C 8005AF4C AC820000 */  sw        $v0, ($a0)
-/* 36350 8005AF50 94620008 */  lhu       $v0, 8($v1)
-/* 36354 8005AF54 24C6001C */  addiu     $a2, $a2, 0x1c
-/* 36358 8005AF58 A4820004 */  sh        $v0, 4($a0)
-/* 3635C 8005AF5C 8602000C */  lh        $v0, 0xc($s0)
-/* 36360 8005AF60 00A2102A */  slt       $v0, $a1, $v0
-/* 36364 8005AF64 1440FFF5 */  bnez      $v0, .L8005AF3C
-/* 36368 8005AF68 24840008 */   addiu    $a0, $a0, 8
-.L8005AF6C:
-/* 3636C 8005AF6C 8FBF0014 */  lw        $ra, 0x14($sp)
-/* 36370 8005AF70 8FB00010 */  lw        $s0, 0x10($sp)
-/* 36374 8005AF74 3C01800E */  lui       $at, %hi(D_800D91DC)
-/* 36378 8005AF78 A42091DC */  sh        $zero, %lo(D_800D91DC)($at)
-/* 3637C 8005AF7C 03E00008 */  jr        $ra
-/* 36380 8005AF80 27BD0018 */   addiu    $sp, $sp, 0x18
diff --git a/ver/us/asm/nonmatchings/362a0_len_2f70/func_8005DB00.s b/ver/us/asm/nonmatchings/362a0_len_2f70/func_8005DB00.s
deleted file mode 100644
index ee838968c5..0000000000
--- a/ver/us/asm/nonmatchings/362a0_len_2f70/func_8005DB00.s
+++ /dev/null
@@ -1,164 +0,0 @@
-.set noat      # allow manual use of $at
-.set noreorder # don't insert nops after branches
-
-glabel func_8005DB00
-/* 38F00 8005DB00 27BDFFD8 */  addiu     $sp, $sp, -0x28
-/* 38F04 8005DB04 AFB20018 */  sw        $s2, 0x18($sp)
-/* 38F08 8005DB08 0080902D */  daddu     $s2, $a0, $zero
-/* 38F0C 8005DB0C AFBF0020 */  sw        $ra, 0x20($sp)
-/* 38F10 8005DB10 AFB3001C */  sw        $s3, 0x1c($sp)
-/* 38F14 8005DB14 AFB10014 */  sw        $s1, 0x14($sp)
-/* 38F18 8005DB18 AFB00010 */  sw        $s0, 0x10($sp)
-/* 38F1C 8005DB1C 8E420148 */  lw        $v0, 0x148($s2)
-/* 38F20 8005DB20 84440008 */  lh        $a0, 8($v0)
-/* 38F24 8005DB24 0C00EABB */  jal       get_npc_unsafe
-/* 38F28 8005DB28 00A0802D */   daddu    $s0, $a1, $zero
-/* 38F2C 8005DB2C 3C138011 */  lui       $s3, %hi(gPlayerStatus)
-/* 38F30 8005DB30 2673EFC8 */  addiu     $s3, $s3, %lo(gPlayerStatus)
-/* 38F34 8005DB34 12000002 */  beqz      $s0, .L8005DB40
-/* 38F38 8005DB38 0040882D */   daddu    $s1, $v0, $zero
-/* 38F3C 8005DB3C AE400070 */  sw        $zero, 0x70($s2)
-.L8005DB40:
-/* 38F40 8005DB40 8E440070 */  lw        $a0, 0x70($s2)
-/* 38F44 8005DB44 10800005 */  beqz      $a0, .L8005DB5C
-/* 38F48 8005DB48 24020001 */   addiu    $v0, $zero, 1
-/* 38F4C 8005DB4C 1082001F */  beq       $a0, $v0, .L8005DBCC
-/* 38F50 8005DB50 0000102D */   daddu    $v0, $zero, $zero
-/* 38F54 8005DB54 0801774E */  j         .L8005DD38
-/* 38F58 8005DB58 00000000 */   nop
-.L8005DB5C:
-/* 38F5C 8005DB5C 0240202D */  daddu     $a0, $s2, $zero
-/* 38F60 8005DB60 3C05FE36 */  lui       $a1, 0xfe36
-/* 38F64 8005DB64 0C0B210B */  jal       evt_get_float_variable
-/* 38F68 8005DB68 34A53C80 */   ori      $a1, $a1, 0x3c80
-/* 38F6C 8005DB6C 0240202D */  daddu     $a0, $s2, $zero
-/* 38F70 8005DB70 3C05FE36 */  lui       $a1, 0xfe36
-/* 38F74 8005DB74 34A53C81 */  ori       $a1, $a1, 0x3c81
-/* 38F78 8005DB78 0C0B1EAF */  jal       evt_get_variable
-/* 38F7C 8005DB7C E6200010 */   swc1     $f0, 0x10($s1)
-/* 38F80 8005DB80 0240202D */  daddu     $a0, $s2, $zero
-/* 38F84 8005DB84 3C05FE36 */  lui       $a1, 0xfe36
-/* 38F88 8005DB88 34A53C82 */  ori       $a1, $a1, 0x3c82
-/* 38F8C 8005DB8C 0C0B1EAF */  jal       evt_get_variable
-/* 38F90 8005DB90 A622008E */   sh       $v0, 0x8e($s1)
-/* 38F94 8005DB94 0240202D */  daddu     $a0, $s2, $zero
-/* 38F98 8005DB98 3C05FE36 */  lui       $a1, 0xfe36
-/* 38F9C 8005DB9C 34A53C83 */  ori       $a1, $a1, 0x3c83
-/* 38FA0 8005DBA0 0C0B1EAF */  jal       evt_get_variable
-/* 38FA4 8005DBA4 AE420074 */   sw       $v0, 0x74($s2)
-/* 38FA8 8005DBA8 00021FC2 */  srl       $v1, $v0, 0x1f
-/* 38FAC 8005DBAC 00621821 */  addu      $v1, $v1, $v0
-/* 38FB0 8005DBB0 8E4200AC */  lw        $v0, 0xac($s2)
-/* 38FB4 8005DBB4 00031843 */  sra       $v1, $v1, 1
-/* 38FB8 8005DBB8 AE430078 */  sw        $v1, 0x78($s2)
-/* 38FBC 8005DBBC AE220028 */  sw        $v0, 0x28($s1)
-/* 38FC0 8005DBC0 24020001 */  addiu     $v0, $zero, 1
-/* 38FC4 8005DBC4 0801774D */  j         .L8005DD34
-/* 38FC8 8005DBC8 AE420070 */   sw       $v0, 0x70($s2)
-.L8005DBCC:
-/* 38FCC 8005DBCC 3C028011 */  lui       $v0, %hi(gPartnerActionStatus)
-/* 38FD0 8005DBD0 2442EBB0 */  addiu     $v0, $v0, %lo(gPartnerActionStatus)
-/* 38FD4 8005DBD4 80430003 */  lb        $v1, 3($v0)
-/* 38FD8 8005DBD8 24020009 */  addiu     $v0, $zero, 9
-/* 38FDC 8005DBDC 10620056 */  beq       $v1, $v0, .L8005DD38
-/* 38FE0 8005DBE0 0000102D */   daddu    $v0, $zero, $zero
-/* 38FE4 8005DBE4 8622008E */  lh        $v0, 0x8e($s1)
-/* 38FE8 8005DBE8 10400005 */  beqz      $v0, .L8005DC00
-/* 38FEC 8005DBEC 00000000 */   nop
-/* 38FF0 8005DBF0 1044002C */  beq       $v0, $a0, .L8005DCA4
-/* 38FF4 8005DBF4 0000102D */   daddu    $v0, $zero, $zero
-/* 38FF8 8005DBF8 0801774E */  j         .L8005DD38
-/* 38FFC 8005DBFC 00000000 */   nop
-.L8005DC00:
-/* 39000 8005DC00 C6620028 */  lwc1      $f2, 0x28($s3)
-/* 39004 8005DC04 C6200038 */  lwc1      $f0, 0x38($s1)
-/* 39008 8005DC08 46001081 */  sub.s     $f2, $f2, $f0
-/* 3900C 8005DC0C 46021082 */  mul.s     $f2, $f2, $f2
-/* 39010 8005DC10 00000000 */  nop
-/* 39014 8005DC14 C666002C */  lwc1      $f6, 0x2c($s3)
-/* 39018 8005DC18 C620003C */  lwc1      $f0, 0x3c($s1)
-/* 3901C 8005DC1C 46003181 */  sub.s     $f6, $f6, $f0
-/* 39020 8005DC20 46063182 */  mul.s     $f6, $f6, $f6
-/* 39024 8005DC24 00000000 */  nop
-/* 39028 8005DC28 C6240040 */  lwc1      $f4, 0x40($s1)
-/* 3902C 8005DC2C C6600030 */  lwc1      $f0, 0x30($s3)
-/* 39030 8005DC30 46040001 */  sub.s     $f0, $f0, $f4
-/* 39034 8005DC34 46000002 */  mul.s     $f0, $f0, $f0
-/* 39038 8005DC38 00000000 */  nop
-/* 3903C 8005DC3C 46061080 */  add.s     $f2, $f2, $f6
-/* 39040 8005DC40 46001300 */  add.s     $f12, $f2, $f0
-/* 39044 8005DC44 46006104 */  sqrt.s    $f4, $f12
-/* 39048 8005DC48 46042032 */  c.eq.s    $f4, $f4
-/* 3904C 8005DC4C 00000000 */  nop
-/* 39050 8005DC50 45010004 */  bc1t      .L8005DC64
-/* 39054 8005DC54 00000000 */   nop
-/* 39058 8005DC58 0C0187BC */  jal       sqrtf
-/* 3905C 8005DC5C 00000000 */   nop
-/* 39060 8005DC60 46000106 */  mov.s     $f4, $f0
-.L8005DC64:
-/* 39064 8005DC64 C6200010 */  lwc1      $f0, 0x10($s1)
-/* 39068 8005DC68 4600203E */  c.le.s    $f4, $f0
-/* 3906C 8005DC6C 00000000 */  nop
-/* 39070 8005DC70 45000031 */  bc1f      .L8005DD38
-/* 39074 8005DC74 0000102D */   daddu    $v0, $zero, $zero
-/* 39078 8005DC78 C62C0038 */  lwc1      $f12, 0x38($s1)
-/* 3907C 8005DC7C C62E0040 */  lwc1      $f14, 0x40($s1)
-/* 39080 8005DC80 8E660028 */  lw        $a2, 0x28($s3)
-/* 39084 8005DC84 0C00A720 */  jal       atan2
-/* 39088 8005DC88 8E670030 */   lw       $a3, 0x30($s3)
-/* 3908C 8005DC8C 8E430074 */  lw        $v1, 0x74($s2)
-/* 39090 8005DC90 2402FFFF */  addiu     $v0, $zero, -1
-/* 39094 8005DC94 10620016 */  beq       $v1, $v0, .L8005DCF0
-/* 39098 8005DC98 00000000 */   nop
-/* 3909C 8005DC9C 0801773E */  j         .L8005DCF8
-/* 390A0 8005DCA0 00000000 */   nop
-.L8005DCA4:
-/* 390A4 8005DCA4 C62C0038 */  lwc1      $f12, 0x38($s1)
-/* 390A8 8005DCA8 C62E0040 */  lwc1      $f14, 0x40($s1)
-/* 390AC 8005DCAC 8E660028 */  lw        $a2, 0x28($s3)
-/* 390B0 8005DCB0 0C00A7B5 */  jal       dist2D
-/* 390B4 8005DCB4 8E670030 */   lw       $a3, 0x30($s3)
-/* 390B8 8005DCB8 C6220010 */  lwc1      $f2, 0x10($s1)
-/* 390BC 8005DCBC 4602003E */  c.le.s    $f0, $f2
-/* 390C0 8005DCC0 00000000 */  nop
-/* 390C4 8005DCC4 4500001C */  bc1f      .L8005DD38
-/* 390C8 8005DCC8 0000102D */   daddu    $v0, $zero, $zero
-/* 390CC 8005DCCC C62C0038 */  lwc1      $f12, 0x38($s1)
-/* 390D0 8005DCD0 C62E0040 */  lwc1      $f14, 0x40($s1)
-/* 390D4 8005DCD4 8E660028 */  lw        $a2, 0x28($s3)
-/* 390D8 8005DCD8 0C00A720 */  jal       atan2
-/* 390DC 8005DCDC 8E670030 */   lw       $a3, 0x30($s3)
-/* 390E0 8005DCE0 8E430074 */  lw        $v1, 0x74($s2)
-/* 390E4 8005DCE4 2402FFFF */  addiu     $v0, $zero, -1
-/* 390E8 8005DCE8 14620003 */  bne       $v1, $v0, .L8005DCF8
-/* 390EC 8005DCEC 00000000 */   nop
-.L8005DCF0:
-/* 390F0 8005DCF0 08017741 */  j         .L8005DD04
-/* 390F4 8005DCF4 C62C000C */   lwc1     $f12, 0xc($s1)
-.L8005DCF8:
-/* 390F8 8005DCF8 44836000 */  mtc1      $v1, $f12
-/* 390FC 8005DCFC 00000000 */  nop
-/* 39100 8005DD00 46806320 */  cvt.s.w   $f12, $f12
-.L8005DD04:
-/* 39104 8005DD04 0C00A70A */  jal       get_clamped_angle_diff
-/* 39108 8005DD08 46000386 */   mov.s    $f14, $f0
-/* 3910C 8005DD0C C6420078 */  lwc1      $f2, 0x78($s2)
-/* 39110 8005DD10 468010A0 */  cvt.s.w   $f2, $f2
-/* 39114 8005DD14 46000005 */  abs.s     $f0, $f0
-/* 39118 8005DD18 4602003C */  c.lt.s    $f0, $f2
-/* 3911C 8005DD1C 00000000 */  nop
-/* 39120 8005DD20 45000004 */  bc1f      .L8005DD34
-/* 39124 8005DD24 24020001 */   addiu    $v0, $zero, 1
-/* 39128 8005DD28 AE420084 */  sw        $v0, 0x84($s2)
-/* 3912C 8005DD2C 0801774E */  j         .L8005DD38
-/* 39130 8005DD30 24020002 */   addiu    $v0, $zero, 2
-.L8005DD34:
-/* 39134 8005DD34 0000102D */  daddu     $v0, $zero, $zero
-.L8005DD38:
-/* 39138 8005DD38 8FBF0020 */  lw        $ra, 0x20($sp)
-/* 3913C 8005DD3C 8FB3001C */  lw        $s3, 0x1c($sp)
-/* 39140 8005DD40 8FB20018 */  lw        $s2, 0x18($sp)
-/* 39144 8005DD44 8FB10014 */  lw        $s1, 0x14($sp)
-/* 39148 8005DD48 8FB00010 */  lw        $s0, 0x10($sp)
-/* 3914C 8005DD4C 03E00008 */  jr        $ra
-/* 39150 8005DD50 27BD0028 */   addiu    $sp, $sp, 0x28
diff --git a/ver/us/asm/nonmatchings/362a0_len_2f70/load_collision.s b/ver/us/asm/nonmatchings/362a0_len_2f70/load_collision.s
deleted file mode 100644
index 29d257bf83..0000000000
--- a/ver/us/asm/nonmatchings/362a0_len_2f70/load_collision.s
+++ /dev/null
@@ -1,91 +0,0 @@
-.set noat      # allow manual use of $at
-.set noreorder # don't insert nops after branches
-
-glabel load_collision
-/* 36458 8005B058 27BDFFD0 */  addiu     $sp, $sp, -0x30
-/* 3645C 8005B05C AFBF002C */  sw        $ra, 0x2c($sp)
-/* 36460 8005B060 AFB60028 */  sw        $s6, 0x28($sp)
-/* 36464 8005B064 AFB50024 */  sw        $s5, 0x24($sp)
-/* 36468 8005B068 AFB40020 */  sw        $s4, 0x20($sp)
-/* 3646C 8005B06C AFB3001C */  sw        $s3, 0x1c($sp)
-/* 36470 8005B070 AFB20018 */  sw        $s2, 0x18($sp)
-/* 36474 8005B074 AFB10014 */  sw        $s1, 0x14($sp)
-/* 36478 8005B078 0C016BF0 */  jal       load_hit_asset
-/* 3647C 8005B07C AFB00010 */   sw       $s0, 0x10($sp)
-/* 36480 8005B080 3C13800B */  lui       $s3, %hi(gCollisionData)
-/* 36484 8005B084 267342E0 */  addiu     $s3, $s3, %lo(gCollisionData)
-/* 36488 8005B088 8662000C */  lh        $v0, 0xc($s3)
-/* 3648C 8005B08C 3C11800A */  lui       $s1, %hi(D_800A4264)
-/* 36490 8005B090 8E314264 */  lw        $s1, %lo(D_800A4264)($s1)
-/* 36494 8005B094 1840001C */  blez      $v0, .L8005B108
-/* 36498 8005B098 0000902D */   daddu    $s2, $zero, $zero
-/* 3649C 8005B09C 2416FFFF */  addiu     $s6, $zero, -1
-/* 364A0 8005B0A0 3C158000 */  lui       $s5, 0x8000
-/* 364A4 8005B0A4 0240A02D */  daddu     $s4, $s2, $zero
-.L8005B0A8:
-/* 364A8 8005B0A8 8E620004 */  lw        $v0, 4($s3)
-/* 364AC 8005B0AC 8E230000 */  lw        $v1, ($s1)
-/* 364B0 8005B0B0 00542021 */  addu      $a0, $v0, $s4
-/* 364B4 8005B0B4 AC830000 */  sw        $v1, ($a0)
-/* 364B8 8005B0B8 96250004 */  lhu       $a1, 4($s1)
-/* 364BC 8005B0BC 0060102D */  daddu     $v0, $v1, $zero
-/* 364C0 8005B0C0 1056000B */  beq       $v0, $s6, .L8005B0F0
-/* 364C4 8005B0C4 A4850008 */   sh       $a1, 8($a0)
-/* 364C8 8005B0C8 00551024 */  and       $v0, $v0, $s5
-/* 364CC 8005B0CC 10400008 */  beqz      $v0, .L8005B0F0
-/* 364D0 8005B0D0 00052C00 */   sll      $a1, $a1, 0x10
-/* 364D4 8005B0D4 00128400 */  sll       $s0, $s2, 0x10
-/* 364D8 8005B0D8 00108403 */  sra       $s0, $s0, 0x10
-/* 364DC 8005B0DC 0200202D */  daddu     $a0, $s0, $zero
-/* 364E0 8005B0E0 0C016DE0 */  jal       parent_collider_to_model
-/* 364E4 8005B0E4 00052C03 */   sra      $a1, $a1, 0x10
-/* 364E8 8005B0E8 0C016E89 */  jal       update_collider_transform
-/* 364EC 8005B0EC 0200202D */   daddu    $a0, $s0, $zero
-.L8005B0F0:
-/* 364F0 8005B0F0 2694001C */  addiu     $s4, $s4, 0x1c
-/* 364F4 8005B0F4 26520001 */  addiu     $s2, $s2, 1
-/* 364F8 8005B0F8 8662000C */  lh        $v0, 0xc($s3)
-/* 364FC 8005B0FC 0242102A */  slt       $v0, $s2, $v0
-/* 36500 8005B100 1440FFE9 */  bnez      $v0, .L8005B0A8
-/* 36504 8005B104 26310008 */   addiu    $s1, $s1, 8
-.L8005B108:
-/* 36508 8005B108 3C13800E */  lui       $s3, %hi(D_800D91D0)
-/* 3650C 8005B10C 267391D0 */  addiu     $s3, $s3, %lo(D_800D91D0)
-/* 36510 8005B110 8662000C */  lh        $v0, 0xc($s3)
-/* 36514 8005B114 3C11800A */  lui       $s1, %hi(D_800A4268)
-/* 36518 8005B118 8E314268 */  lw        $s1, %lo(D_800A4268)($s1)
-/* 3651C 8005B11C 1840000E */  blez      $v0, .L8005B158
-/* 36520 8005B120 0000902D */   daddu    $s2, $zero, $zero
-/* 36524 8005B124 0240282D */  daddu     $a1, $s2, $zero
-.L8005B128:
-/* 36528 8005B128 26520001 */  addiu     $s2, $s2, 1
-/* 3652C 8005B12C 8E620004 */  lw        $v0, 4($s3)
-/* 36530 8005B130 8E230000 */  lw        $v1, ($s1)
-/* 36534 8005B134 00452021 */  addu      $a0, $v0, $a1
-/* 36538 8005B138 AC830000 */  sw        $v1, ($a0)
-/* 3653C 8005B13C 96220004 */  lhu       $v0, 4($s1)
-/* 36540 8005B140 24A5001C */  addiu     $a1, $a1, 0x1c
-/* 36544 8005B144 A4820008 */  sh        $v0, 8($a0)
-/* 36548 8005B148 8662000C */  lh        $v0, 0xc($s3)
-/* 3654C 8005B14C 0242102A */  slt       $v0, $s2, $v0
-/* 36550 8005B150 1440FFF5 */  bnez      $v0, .L8005B128
-/* 36554 8005B154 26310008 */   addiu    $s1, $s1, 8
-.L8005B158:
-/* 36558 8005B158 3C04800A */  lui       $a0, %hi(D_800A4264)
-/* 3655C 8005B15C 8C844264 */  lw        $a0, %lo(D_800A4264)($a0)
-/* 36560 8005B160 0C00AB1E */  jal       general_heap_free
-/* 36564 8005B164 00000000 */   nop
-/* 36568 8005B168 3C04800A */  lui       $a0, %hi(D_800A4268)
-/* 3656C 8005B16C 8C844268 */  lw        $a0, %lo(D_800A4268)($a0)
-/* 36570 8005B170 0C00AB1E */  jal       general_heap_free
-/* 36574 8005B174 00000000 */   nop
-/* 36578 8005B178 8FBF002C */  lw        $ra, 0x2c($sp)
-/* 3657C 8005B17C 8FB60028 */  lw        $s6, 0x28($sp)
-/* 36580 8005B180 8FB50024 */  lw        $s5, 0x24($sp)
-/* 36584 8005B184 8FB40020 */  lw        $s4, 0x20($sp)
-/* 36588 8005B188 8FB3001C */  lw        $s3, 0x1c($sp)
-/* 3658C 8005B18C 8FB20018 */  lw        $s2, 0x18($sp)
-/* 36590 8005B190 8FB10014 */  lw        $s1, 0x14($sp)
-/* 36594 8005B194 8FB00010 */  lw        $s0, 0x10($sp)
-/* 36598 8005B198 03E00008 */  jr        $ra
-/* 3659C 8005B19C 27BD0030 */   addiu    $sp, $sp, 0x30
diff --git a/ver/us/asm/nonmatchings/362a0_len_2f70/load_hit_data.s b/ver/us/asm/nonmatchings/362a0_len_2f70/load_hit_data.s
deleted file mode 100644
index 1513f0557c..0000000000
--- a/ver/us/asm/nonmatchings/362a0_len_2f70/load_hit_data.s
+++ /dev/null
@@ -1,359 +0,0 @@
-.set noat      # allow manual use of $at
-.set noreorder # don't insert nops after branches
-
-glabel load_hit_data
-/* 3663C 8005B23C 27BDFF90 */  addiu     $sp, $sp, -0x70
-/* 36640 8005B240 AFB60038 */  sw        $s6, 0x38($sp)
-/* 36644 8005B244 0000B02D */  daddu     $s6, $zero, $zero
-/* 36648 8005B248 AFBE0040 */  sw        $fp, 0x40($sp)
-/* 3664C 8005B24C 02C0F02D */  daddu     $fp, $s6, $zero
-/* 36650 8005B250 AFBF0044 */  sw        $ra, 0x44($sp)
-/* 36654 8005B254 AFB7003C */  sw        $s7, 0x3c($sp)
-/* 36658 8005B258 AFB50034 */  sw        $s5, 0x34($sp)
-/* 3665C 8005B25C AFB40030 */  sw        $s4, 0x30($sp)
-/* 36660 8005B260 AFB3002C */  sw        $s3, 0x2c($sp)
-/* 36664 8005B264 AFB20028 */  sw        $s2, 0x28($sp)
-/* 36668 8005B268 AFB10024 */  sw        $s1, 0x24($sp)
-/* 3666C 8005B26C AFB00020 */  sw        $s0, 0x20($sp)
-/* 36670 8005B270 F7BC0068 */  sdc1      $f28, 0x68($sp)
-/* 36674 8005B274 F7BA0060 */  sdc1      $f26, 0x60($sp)
-/* 36678 8005B278 F7B80058 */  sdc1      $f24, 0x58($sp)
-/* 3667C 8005B27C F7B60050 */  sdc1      $f22, 0x50($sp)
-/* 36680 8005B280 F7B40048 */  sdc1      $f20, 0x48($sp)
-/* 36684 8005B284 AFA40070 */  sw        $a0, 0x70($sp)
-/* 36688 8005B288 0C016AFA */  jal       get_current_map_header
-/* 3668C 8005B28C AFA50074 */   sw       $a1, 0x74($sp)
-/* 36690 8005B290 8FA80070 */  lw        $t0, 0x70($sp)
-/* 36694 8005B294 11000006 */  beqz      $t0, .L8005B2B0
-/* 36698 8005B298 0040182D */   daddu    $v1, $v0, $zero
-/* 3669C 8005B29C 24020001 */  addiu     $v0, $zero, 1
-/* 366A0 8005B2A0 1102000B */  beq       $t0, $v0, .L8005B2D0
-/* 366A4 8005B2A4 0000A02D */   daddu    $s4, $zero, $zero
-/* 366A8 8005B2A8 08016CBC */  j         .L8005B2F0
-/* 366AC 8005B2AC 00000000 */   nop
-.L8005B2B0:
-/* 366B0 8005B2B0 8C620004 */  lw        $v0, 4($v1)
-/* 366B4 8005B2B4 10400121 */  beqz      $v0, .L8005B73C
-/* 366B8 8005B2B8 00000000 */   nop
-/* 366BC 8005B2BC 8FA80074 */  lw        $t0, 0x74($sp)
-/* 366C0 8005B2C0 3C1E800B */  lui       $fp, %hi(gCollisionData)
-/* 366C4 8005B2C4 27DE42E0 */  addiu     $fp, $fp, %lo(gCollisionData)
-/* 366C8 8005B2C8 08016CBB */  j         .L8005B2EC
-/* 366CC 8005B2CC 0102B021 */   addu     $s6, $t0, $v0
-.L8005B2D0:
-/* 366D0 8005B2D0 8C620008 */  lw        $v0, 8($v1)
-/* 366D4 8005B2D4 10400119 */  beqz      $v0, .L8005B73C
-/* 366D8 8005B2D8 00000000 */   nop
-/* 366DC 8005B2DC 8FA80074 */  lw        $t0, 0x74($sp)
-/* 366E0 8005B2E0 0102B021 */  addu      $s6, $t0, $v0
-/* 366E4 8005B2E4 3C1E800E */  lui       $fp, %hi(D_800D91D0)
-/* 366E8 8005B2E8 27DE91D0 */  addiu     $fp, $fp, %lo(D_800D91D0)
-.L8005B2EC:
-/* 366EC 8005B2EC 0000A02D */  daddu     $s4, $zero, $zero
-.L8005B2F0:
-/* 366F0 8005B2F0 8EC20014 */  lw        $v0, 0x14($s6)
-/* 366F4 8005B2F4 8FA80074 */  lw        $t0, 0x74($sp)
-/* 366F8 8005B2F8 86C40010 */  lh        $a0, 0x10($s6)
-/* 366FC 8005B2FC 01028021 */  addu      $s0, $t0, $v0
-/* 36700 8005B300 0C00AB6C */  jal       collision_heap_malloc
-/* 36704 8005B304 00042080 */   sll      $a0, $a0, 2
-/* 36708 8005B308 AFC20008 */  sw        $v0, 8($fp)
-/* 3670C 8005B30C 86C30010 */  lh        $v1, 0x10($s6)
-/* 36710 8005B310 18600009 */  blez      $v1, .L8005B338
-/* 36714 8005B314 0040202D */   daddu    $a0, $v0, $zero
-.L8005B318:
-/* 36718 8005B318 8E020000 */  lw        $v0, ($s0)
-/* 3671C 8005B31C 26100004 */  addiu     $s0, $s0, 4
-/* 36720 8005B320 26940001 */  addiu     $s4, $s4, 1
-/* 36724 8005B324 AC820000 */  sw        $v0, ($a0)
-/* 36728 8005B328 86C20010 */  lh        $v0, 0x10($s6)
-/* 3672C 8005B32C 0282102A */  slt       $v0, $s4, $v0
-/* 36730 8005B330 1440FFF9 */  bnez      $v0, .L8005B318
-/* 36734 8005B334 24840004 */   addiu    $a0, $a0, 4
-.L8005B338:
-/* 36738 8005B338 0000A02D */  daddu     $s4, $zero, $zero
-/* 3673C 8005B33C 8EC2000C */  lw        $v0, 0xc($s6)
-/* 36740 8005B340 8FA80074 */  lw        $t0, 0x74($sp)
-/* 36744 8005B344 86C30008 */  lh        $v1, 8($s6)
-/* 36748 8005B348 01028021 */  addu      $s0, $t0, $v0
-/* 3674C 8005B34C 00032040 */  sll       $a0, $v1, 1
-/* 36750 8005B350 00832021 */  addu      $a0, $a0, $v1
-/* 36754 8005B354 0C00AB6C */  jal       collision_heap_malloc
-/* 36758 8005B358 00042080 */   sll      $a0, $a0, 2
-/* 3675C 8005B35C AFC20000 */  sw        $v0, ($fp)
-/* 36760 8005B360 86C30008 */  lh        $v1, 8($s6)
-/* 36764 8005B364 1860001A */  blez      $v1, .L8005B3D0
-/* 36768 8005B368 0040282D */   daddu    $a1, $v0, $zero
-/* 3676C 8005B36C 26040004 */  addiu     $a0, $s0, 4
-/* 36770 8005B370 24A30008 */  addiu     $v1, $a1, 8
-.L8005B374:
-/* 36774 8005B374 86020000 */  lh        $v0, ($s0)
-/* 36778 8005B378 26100006 */  addiu     $s0, $s0, 6
-/* 3677C 8005B37C 26940001 */  addiu     $s4, $s4, 1
-/* 36780 8005B380 44820000 */  mtc1      $v0, $f0
-/* 36784 8005B384 00000000 */  nop
-/* 36788 8005B388 46800020 */  cvt.s.w   $f0, $f0
-/* 3678C 8005B38C E4A00000 */  swc1      $f0, ($a1)
-/* 36790 8005B390 8482FFFE */  lh        $v0, -2($a0)
-/* 36794 8005B394 24A5000C */  addiu     $a1, $a1, 0xc
-/* 36798 8005B398 44820000 */  mtc1      $v0, $f0
-/* 3679C 8005B39C 00000000 */  nop
-/* 367A0 8005B3A0 46800020 */  cvt.s.w   $f0, $f0
-/* 367A4 8005B3A4 E460FFFC */  swc1      $f0, -4($v1)
-/* 367A8 8005B3A8 84820000 */  lh        $v0, ($a0)
-/* 367AC 8005B3AC 24840006 */  addiu     $a0, $a0, 6
-/* 367B0 8005B3B0 44820000 */  mtc1      $v0, $f0
-/* 367B4 8005B3B4 00000000 */  nop
-/* 367B8 8005B3B8 46800020 */  cvt.s.w   $f0, $f0
-/* 367BC 8005B3BC E4600000 */  swc1      $f0, ($v1)
-/* 367C0 8005B3C0 86C20008 */  lh        $v0, 8($s6)
-/* 367C4 8005B3C4 0282102A */  slt       $v0, $s4, $v0
-/* 367C8 8005B3C8 1440FFEA */  bnez      $v0, .L8005B374
-/* 367CC 8005B3CC 2463000C */   addiu    $v1, $v1, 0xc
-.L8005B3D0:
-/* 367D0 8005B3D0 8EC20004 */  lw        $v0, 4($s6)
-/* 367D4 8005B3D4 8FA80074 */  lw        $t0, 0x74($sp)
-/* 367D8 8005B3D8 86C30000 */  lh        $v1, ($s6)
-/* 367DC 8005B3DC 01021021 */  addu      $v0, $t0, $v0
-/* 367E0 8005B3E0 000320C0 */  sll       $a0, $v1, 3
-/* 367E4 8005B3E4 00832023 */  subu      $a0, $a0, $v1
-/* 367E8 8005B3E8 00042080 */  sll       $a0, $a0, 2
-/* 367EC 8005B3EC 0C00AB6C */  jal       collision_heap_malloc
-/* 367F0 8005B3F0 AFA20010 */   sw       $v0, 0x10($sp)
-/* 367F4 8005B3F4 AFC20004 */  sw        $v0, 4($fp)
-/* 367F8 8005B3F8 96C30000 */  lhu       $v1, ($s6)
-/* 367FC 8005B3FC 0000A02D */  daddu     $s4, $zero, $zero
-/* 36800 8005B400 A7C3000C */  sh        $v1, 0xc($fp)
-/* 36804 8005B404 86C30000 */  lh        $v1, ($s6)
-/* 36808 8005B408 186000CC */  blez      $v1, .L8005B73C
-/* 3680C 8005B40C 0040382D */   daddu    $a3, $v0, $zero
-/* 36810 8005B410 24F20010 */  addiu     $s2, $a3, 0x10
-/* 36814 8005B414 8FA80010 */  lw        $t0, 0x10($sp)
-/* 36818 8005B418 3C013F80 */  lui       $at, 0x3f80
-/* 3681C 8005B41C 4481D000 */  mtc1      $at, $f26
-/* 36820 8005B420 4480E000 */  mtc1      $zero, $f28
-/* 36824 8005B424 25130006 */  addiu     $s3, $t0, 6
-.L8005B428:
-/* 36828 8005B428 ACE00000 */  sw        $zero, ($a3)
-/* 3682C 8005B42C 9662FFFC */  lhu       $v0, -4($s3)
-/* 36830 8005B430 A642FFF4 */  sh        $v0, -0xc($s2)
-/* 36834 8005B434 9662FFFE */  lhu       $v0, -2($s3)
-/* 36838 8005B438 A642FFF6 */  sh        $v0, -0xa($s2)
-/* 3683C 8005B43C 96620000 */  lhu       $v0, ($s3)
-/* 36840 8005B440 A642FFFA */  sh        $v0, -6($s2)
-/* 36844 8005B444 00021400 */  sll       $v0, $v0, 0x10
-/* 36848 8005B448 504000B3 */  beql      $v0, $zero, .L8005B718
-/* 3684C 8005B44C 2673000C */   addiu    $s3, $s3, 0xc
-/* 36850 8005B450 86640000 */  lh        $a0, ($s3)
-/* 36854 8005B454 AFA70018 */  sw        $a3, 0x18($sp)
-/* 36858 8005B458 0C00AB6C */  jal       collision_heap_malloc
-/* 3685C 8005B45C 00042180 */   sll      $a0, $a0, 6
-/* 36860 8005B460 0040B82D */  daddu     $s7, $v0, $zero
-/* 36864 8005B464 AE57FFFC */  sw        $s7, -4($s2)
-/* 36868 8005B468 8FA80010 */  lw        $t0, 0x10($sp)
-/* 3686C 8005B46C 85020000 */  lh        $v0, ($t0)
-/* 36870 8005B470 8FA70018 */  lw        $a3, 0x18($sp)
-/* 36874 8005B474 04410003 */  bgez      $v0, .L8005B484
-/* 36878 8005B478 00021080 */   sll      $v0, $v0, 2
-/* 3687C 8005B47C 08016D41 */  j         .L8005B504
-/* 36880 8005B480 AE400000 */   sw       $zero, ($s2)
-.L8005B484:
-/* 36884 8005B484 8FC30008 */  lw        $v1, 8($fp)
-/* 36888 8005B488 00621821 */  addu      $v1, $v1, $v0
-/* 3688C 8005B48C AE430000 */  sw        $v1, ($s2)
-/* 36890 8005B490 8FA80070 */  lw        $t0, 0x70($sp)
-/* 36894 8005B494 1500001C */  bnez      $t0, .L8005B508
-/* 36898 8005B498 0000A82D */   daddu    $s5, $zero, $zero
-/* 3689C 8005B49C C4600000 */  lwc1      $f0, ($v1)
-/* 368A0 8005B4A0 461A0001 */  sub.s     $f0, $f0, $f26
-/* 368A4 8005B4A4 E4600000 */  swc1      $f0, ($v1)
-/* 368A8 8005B4A8 8E420000 */  lw        $v0, ($s2)
-/* 368AC 8005B4AC C4400004 */  lwc1      $f0, 4($v0)
-/* 368B0 8005B4B0 461A0001 */  sub.s     $f0, $f0, $f26
-/* 368B4 8005B4B4 E4400004 */  swc1      $f0, 4($v0)
-/* 368B8 8005B4B8 8E420000 */  lw        $v0, ($s2)
-/* 368BC 8005B4BC C4400008 */  lwc1      $f0, 8($v0)
-/* 368C0 8005B4C0 461A0001 */  sub.s     $f0, $f0, $f26
-/* 368C4 8005B4C4 E4400008 */  swc1      $f0, 8($v0)
-/* 368C8 8005B4C8 8E420000 */  lw        $v0, ($s2)
-/* 368CC 8005B4CC C440000C */  lwc1      $f0, 0xc($v0)
-/* 368D0 8005B4D0 461A0000 */  add.s     $f0, $f0, $f26
-/* 368D4 8005B4D4 E440000C */  swc1      $f0, 0xc($v0)
-/* 368D8 8005B4D8 8E420000 */  lw        $v0, ($s2)
-/* 368DC 8005B4DC C4400010 */  lwc1      $f0, 0x10($v0)
-/* 368E0 8005B4E0 461A0000 */  add.s     $f0, $f0, $f26
-/* 368E4 8005B4E4 E4400010 */  swc1      $f0, 0x10($v0)
-/* 368E8 8005B4E8 8E420000 */  lw        $v0, ($s2)
-/* 368EC 8005B4EC C4400014 */  lwc1      $f0, 0x14($v0)
-/* 368F0 8005B4F0 461A0000 */  add.s     $f0, $f0, $f26
-/* 368F4 8005B4F4 E4400014 */  swc1      $f0, 0x14($v0)
-/* 368F8 8005B4F8 8E420000 */  lw        $v0, ($s2)
-/* 368FC 8005B4FC 8C420018 */  lw        $v0, 0x18($v0)
-/* 36900 8005B500 ACE20000 */  sw        $v0, ($a3)
-.L8005B504:
-/* 36904 8005B504 0000A82D */  daddu     $s5, $zero, $zero
-.L8005B508:
-/* 36908 8005B508 8E620002 */  lw        $v0, 2($s3)
-/* 3690C 8005B50C 8FA80074 */  lw        $t0, 0x74($sp)
-/* 36910 8005B510 86630000 */  lh        $v1, ($s3)
-/* 36914 8005B514 1860007F */  blez      $v1, .L8005B714
-/* 36918 8005B518 01028821 */   addu     $s1, $t0, $v0
-/* 3691C 8005B51C 26F00038 */  addiu     $s0, $s7, 0x38
-.L8005B520:
-/* 36920 8005B520 8E230000 */  lw        $v1, ($s1)
-/* 36924 8005B524 8FC40000 */  lw        $a0, ($fp)
-/* 36928 8005B528 306303FF */  andi      $v1, $v1, 0x3ff
-/* 3692C 8005B52C 00031040 */  sll       $v0, $v1, 1
-/* 36930 8005B530 00431021 */  addu      $v0, $v0, $v1
-/* 36934 8005B534 00021080 */  sll       $v0, $v0, 2
-/* 36938 8005B538 00822021 */  addu      $a0, $a0, $v0
-/* 3693C 8005B53C AEE40000 */  sw        $a0, ($s7)
-/* 36940 8005B540 8E220000 */  lw        $v0, ($s1)
-/* 36944 8005B544 8FC60000 */  lw        $a2, ($fp)
-/* 36948 8005B548 00021283 */  sra       $v0, $v0, 0xa
-/* 3694C 8005B54C 304203FF */  andi      $v0, $v0, 0x3ff
-/* 36950 8005B550 00021840 */  sll       $v1, $v0, 1
-/* 36954 8005B554 00621821 */  addu      $v1, $v1, $v0
-/* 36958 8005B558 00031880 */  sll       $v1, $v1, 2
-/* 3695C 8005B55C 00C33021 */  addu      $a2, $a2, $v1
-/* 36960 8005B560 AE06FFCC */  sw        $a2, -0x34($s0)
-/* 36964 8005B564 8E220000 */  lw        $v0, ($s1)
-/* 36968 8005B568 8FC50000 */  lw        $a1, ($fp)
-/* 3696C 8005B56C 00021503 */  sra       $v0, $v0, 0x14
-/* 36970 8005B570 304203FF */  andi      $v0, $v0, 0x3ff
-/* 36974 8005B574 00021840 */  sll       $v1, $v0, 1
-/* 36978 8005B578 00621821 */  addu      $v1, $v1, $v0
-/* 3697C 8005B57C 00031880 */  sll       $v1, $v1, 2
-/* 36980 8005B580 00A32821 */  addu      $a1, $a1, $v1
-/* 36984 8005B584 AE05FFD0 */  sw        $a1, -0x30($s0)
-/* 36988 8005B588 8E220000 */  lw        $v0, ($s1)
-/* 3698C 8005B58C 00021783 */  sra       $v0, $v0, 0x1e
-/* 36990 8005B590 30420001 */  andi      $v0, $v0, 1
-/* 36994 8005B594 A6020004 */  sh        $v0, 4($s0)
-/* 36998 8005B598 C4A00000 */  lwc1      $f0, ($a1)
-/* 3699C 8005B59C C4820000 */  lwc1      $f2, ($a0)
-/* 369A0 8005B5A0 46020001 */  sub.s     $f0, $f0, $f2
-/* 369A4 8005B5A4 E600FFD4 */  swc1      $f0, -0x2c($s0)
-/* 369A8 8005B5A8 C4A00004 */  lwc1      $f0, 4($a1)
-/* 369AC 8005B5AC C4820004 */  lwc1      $f2, 4($a0)
-/* 369B0 8005B5B0 46020001 */  sub.s     $f0, $f0, $f2
-/* 369B4 8005B5B4 E600FFD8 */  swc1      $f0, -0x28($s0)
-/* 369B8 8005B5B8 C4A00008 */  lwc1      $f0, 8($a1)
-/* 369BC 8005B5BC C4820008 */  lwc1      $f2, 8($a0)
-/* 369C0 8005B5C0 46020001 */  sub.s     $f0, $f0, $f2
-/* 369C4 8005B5C4 E600FFDC */  swc1      $f0, -0x24($s0)
-/* 369C8 8005B5C8 C4800000 */  lwc1      $f0, ($a0)
-/* 369CC 8005B5CC C4C20000 */  lwc1      $f2, ($a2)
-/* 369D0 8005B5D0 46020001 */  sub.s     $f0, $f0, $f2
-/* 369D4 8005B5D4 E600FFE0 */  swc1      $f0, -0x20($s0)
-/* 369D8 8005B5D8 C4800004 */  lwc1      $f0, 4($a0)
-/* 369DC 8005B5DC C4C20004 */  lwc1      $f2, 4($a2)
-/* 369E0 8005B5E0 46020001 */  sub.s     $f0, $f0, $f2
-/* 369E4 8005B5E4 E600FFE4 */  swc1      $f0, -0x1c($s0)
-/* 369E8 8005B5E8 C4800008 */  lwc1      $f0, 8($a0)
-/* 369EC 8005B5EC C4C20008 */  lwc1      $f2, 8($a2)
-/* 369F0 8005B5F0 46020001 */  sub.s     $f0, $f0, $f2
-/* 369F4 8005B5F4 E600FFE8 */  swc1      $f0, -0x18($s0)
-/* 369F8 8005B5F8 C4C00000 */  lwc1      $f0, ($a2)
-/* 369FC 8005B5FC C4A20000 */  lwc1      $f2, ($a1)
-/* 36A00 8005B600 46020001 */  sub.s     $f0, $f0, $f2
-/* 36A04 8005B604 E600FFEC */  swc1      $f0, -0x14($s0)
-/* 36A08 8005B608 C4C00004 */  lwc1      $f0, 4($a2)
-/* 36A0C 8005B60C C4A20004 */  lwc1      $f2, 4($a1)
-/* 36A10 8005B610 46020001 */  sub.s     $f0, $f0, $f2
-/* 36A14 8005B614 E600FFF0 */  swc1      $f0, -0x10($s0)
-/* 36A18 8005B618 C60AFFD8 */  lwc1      $f10, -0x28($s0)
-/* 36A1C 8005B61C C608FFE8 */  lwc1      $f8, -0x18($s0)
-/* 36A20 8005B620 46085382 */  mul.s     $f14, $f10, $f8
-/* 36A24 8005B624 00000000 */  nop
-/* 36A28 8005B628 C606FFDC */  lwc1      $f6, -0x24($s0)
-/* 36A2C 8005B62C C604FFE4 */  lwc1      $f4, -0x1c($s0)
-/* 36A30 8005B630 46043302 */  mul.s     $f12, $f6, $f4
-/* 36A34 8005B634 00000000 */  nop
-/* 36A38 8005B638 C602FFE0 */  lwc1      $f2, -0x20($s0)
-/* 36A3C 8005B63C 46023182 */  mul.s     $f6, $f6, $f2
-/* 36A40 8005B640 00000000 */  nop
-/* 36A44 8005B644 C600FFD4 */  lwc1      $f0, -0x2c($s0)
-/* 36A48 8005B648 46080202 */  mul.s     $f8, $f0, $f8
-/* 36A4C 8005B64C 00000000 */  nop
-/* 36A50 8005B650 46040002 */  mul.s     $f0, $f0, $f4
-/* 36A54 8005B654 00000000 */  nop
-/* 36A58 8005B658 46025282 */  mul.s     $f10, $f10, $f2
-/* 36A5C 8005B65C 00000000 */  nop
-/* 36A60 8005B660 460C7601 */  sub.s     $f24, $f14, $f12
-/* 36A64 8005B664 4618C102 */  mul.s     $f4, $f24, $f24
-/* 36A68 8005B668 00000000 */  nop
-/* 36A6C 8005B66C 46083501 */  sub.s     $f20, $f6, $f8
-/* 36A70 8005B670 4614A182 */  mul.s     $f6, $f20, $f20
-/* 36A74 8005B674 00000000 */  nop
-/* 36A78 8005B678 460A0581 */  sub.s     $f22, $f0, $f10
-/* 36A7C 8005B67C 4616B202 */  mul.s     $f8, $f22, $f22
-/* 36A80 8005B680 00000000 */  nop
-/* 36A84 8005B684 C4C20008 */  lwc1      $f2, 8($a2)
-/* 36A88 8005B688 C4A00008 */  lwc1      $f0, 8($a1)
-/* 36A8C 8005B68C 46001081 */  sub.s     $f2, $f2, $f0
-/* 36A90 8005B690 46062100 */  add.s     $f4, $f4, $f6
-/* 36A94 8005B694 46082300 */  add.s     $f12, $f4, $f8
-/* 36A98 8005B698 461C6032 */  c.eq.s    $f12, $f28
-/* 36A9C 8005B69C 00000000 */  nop
-/* 36AA0 8005B6A0 4501000B */  bc1t      .L8005B6D0
-/* 36AA4 8005B6A4 E602FFF4 */   swc1     $f2, -0xc($s0)
-/* 36AA8 8005B6A8 46006004 */  sqrt.s    $f0, $f12
-/* 36AAC 8005B6AC 46000032 */  c.eq.s    $f0, $f0
-/* 36AB0 8005B6B0 00000000 */  nop
-/* 36AB4 8005B6B4 45030007 */  bc1tl     .L8005B6D4
-/* 36AB8 8005B6B8 4600D303 */   div.s    $f12, $f26, $f0
-/* 36ABC 8005B6BC 0C0187BC */  jal       sqrtf
-/* 36AC0 8005B6C0 AFA70018 */   sw       $a3, 0x18($sp)
-/* 36AC4 8005B6C4 8FA70018 */  lw        $a3, 0x18($sp)
-/* 36AC8 8005B6C8 08016DB5 */  j         .L8005B6D4
-/* 36ACC 8005B6CC 4600D303 */   div.s    $f12, $f26, $f0
-.L8005B6D0:
-/* 36AD0 8005B6D0 4600E306 */  mov.s     $f12, $f28
-.L8005B6D4:
-/* 36AD4 8005B6D4 460CC082 */  mul.s     $f2, $f24, $f12
-/* 36AD8 8005B6D8 00000000 */  nop
-/* 36ADC 8005B6DC 460CA102 */  mul.s     $f4, $f20, $f12
-/* 36AE0 8005B6E0 00000000 */  nop
-/* 36AE4 8005B6E4 26310004 */  addiu     $s1, $s1, 4
-/* 36AE8 8005B6E8 460CB002 */  mul.s     $f0, $f22, $f12
-/* 36AEC 8005B6EC 00000000 */  nop
-/* 36AF0 8005B6F0 26F70040 */  addiu     $s7, $s7, 0x40
-/* 36AF4 8005B6F4 26B50001 */  addiu     $s5, $s5, 1
-/* 36AF8 8005B6F8 E602FFF8 */  swc1      $f2, -8($s0)
-/* 36AFC 8005B6FC E604FFFC */  swc1      $f4, -4($s0)
-/* 36B00 8005B700 E6000000 */  swc1      $f0, ($s0)
-/* 36B04 8005B704 86620000 */  lh        $v0, ($s3)
-/* 36B08 8005B708 02A2102A */  slt       $v0, $s5, $v0
-/* 36B0C 8005B70C 1440FF84 */  bnez      $v0, .L8005B520
-/* 36B10 8005B710 26100040 */   addiu    $s0, $s0, 0x40
-.L8005B714:
-/* 36B14 8005B714 2673000C */  addiu     $s3, $s3, 0xc
-.L8005B718:
-/* 36B18 8005B718 2652001C */  addiu     $s2, $s2, 0x1c
-/* 36B1C 8005B71C 8FA80010 */  lw        $t0, 0x10($sp)
-/* 36B20 8005B720 2508000C */  addiu     $t0, $t0, 0xc
-/* 36B24 8005B724 AFA80010 */  sw        $t0, 0x10($sp)
-/* 36B28 8005B728 86C20000 */  lh        $v0, ($s6)
-/* 36B2C 8005B72C 26940001 */  addiu     $s4, $s4, 1
-/* 36B30 8005B730 0282102A */  slt       $v0, $s4, $v0
-/* 36B34 8005B734 1440FF3C */  bnez      $v0, .L8005B428
-/* 36B38 8005B738 24E7001C */   addiu    $a3, $a3, 0x1c
-.L8005B73C:
-/* 36B3C 8005B73C 8FBF0044 */  lw        $ra, 0x44($sp)
-/* 36B40 8005B740 8FBE0040 */  lw        $fp, 0x40($sp)
-/* 36B44 8005B744 8FB7003C */  lw        $s7, 0x3c($sp)
-/* 36B48 8005B748 8FB60038 */  lw        $s6, 0x38($sp)
-/* 36B4C 8005B74C 8FB50034 */  lw        $s5, 0x34($sp)
-/* 36B50 8005B750 8FB40030 */  lw        $s4, 0x30($sp)
-/* 36B54 8005B754 8FB3002C */  lw        $s3, 0x2c($sp)
-/* 36B58 8005B758 8FB20028 */  lw        $s2, 0x28($sp)
-/* 36B5C 8005B75C 8FB10024 */  lw        $s1, 0x24($sp)
-/* 36B60 8005B760 8FB00020 */  lw        $s0, 0x20($sp)
-/* 36B64 8005B764 D7BC0068 */  ldc1      $f28, 0x68($sp)
-/* 36B68 8005B768 D7BA0060 */  ldc1      $f26, 0x60($sp)
-/* 36B6C 8005B76C D7B80058 */  ldc1      $f24, 0x58($sp)
-/* 36B70 8005B770 D7B60050 */  ldc1      $f22, 0x50($sp)
-/* 36B74 8005B774 D7B40048 */  ldc1      $f20, 0x48($sp)
-/* 36B78 8005B778 03E00008 */  jr        $ra
-/* 36B7C 8005B77C 27BD0070 */   addiu    $sp, $sp, 0x70
diff --git a/ver/us/asm/nonmatchings/362a0_len_2f70/parent_collider_to_model.s b/ver/us/asm/nonmatchings/362a0_len_2f70/parent_collider_to_model.s
deleted file mode 100644
index ef36724819..0000000000
--- a/ver/us/asm/nonmatchings/362a0_len_2f70/parent_collider_to_model.s
+++ /dev/null
@@ -1,146 +0,0 @@
-.set noat      # allow manual use of $at
-.set noreorder # don't insert nops after branches
-
-glabel parent_collider_to_model
-/* 36B80 8005B780 27BDFFC8 */  addiu     $sp, $sp, -0x38
-/* 36B84 8005B784 00042400 */  sll       $a0, $a0, 0x10
-/* 36B88 8005B788 00042403 */  sra       $a0, $a0, 0x10
-/* 36B8C 8005B78C 000410C0 */  sll       $v0, $a0, 3
-/* 36B90 8005B790 00441023 */  subu      $v0, $v0, $a0
-/* 36B94 8005B794 3C03800B */  lui       $v1, %hi(gCollisionData+0x4)
-/* 36B98 8005B798 8C6342E4 */  lw        $v1, %lo(gCollisionData+0x4)($v1)
-/* 36B9C 8005B79C 00021080 */  sll       $v0, $v0, 2
-/* 36BA0 8005B7A0 AFB30024 */  sw        $s3, 0x24($sp)
-/* 36BA4 8005B7A4 0000982D */  daddu     $s3, $zero, $zero
-/* 36BA8 8005B7A8 AFBF0034 */  sw        $ra, 0x34($sp)
-/* 36BAC 8005B7AC AFB60030 */  sw        $s6, 0x30($sp)
-/* 36BB0 8005B7B0 AFB5002C */  sw        $s5, 0x2c($sp)
-/* 36BB4 8005B7B4 AFB40028 */  sw        $s4, 0x28($sp)
-/* 36BB8 8005B7B8 AFB20020 */  sw        $s2, 0x20($sp)
-/* 36BBC 8005B7BC AFB1001C */  sw        $s1, 0x1c($sp)
-/* 36BC0 8005B7C0 AFB00018 */  sw        $s0, 0x18($sp)
-/* 36BC4 8005B7C4 0062A021 */  addu      $s4, $v1, $v0
-/* 36BC8 8005B7C8 8682000A */  lh        $v0, 0xa($s4)
-/* 36BCC 8005B7CC 3C038000 */  lui       $v1, 0x8000
-/* 36BD0 8005B7D0 A6850008 */  sh        $a1, 8($s4)
-/* 36BD4 8005B7D4 00022040 */  sll       $a0, $v0, 1
-/* 36BD8 8005B7D8 00822021 */  addu      $a0, $a0, $v0
-/* 36BDC 8005B7DC 8E820000 */  lw        $v0, ($s4)
-/* 36BE0 8005B7E0 00042080 */  sll       $a0, $a0, 2
-/* 36BE4 8005B7E4 00431025 */  or        $v0, $v0, $v1
-/* 36BE8 8005B7E8 0C00AB6C */  jal       collision_heap_malloc
-/* 36BEC 8005B7EC AE820000 */   sw       $v0, ($s4)
-/* 36BF0 8005B7F0 0040A82D */  daddu     $s5, $v0, $zero
-/* 36BF4 8005B7F4 8E91000C */  lw        $s1, 0xc($s4)
-/* 36BF8 8005B7F8 8682000A */  lh        $v0, 0xa($s4)
-/* 36BFC 8005B7FC 02A0B02D */  daddu     $s6, $s5, $zero
-/* 36C00 8005B800 18400015 */  blez      $v0, .L8005B858
-/* 36C04 8005B804 AFA00010 */   sw       $zero, 0x10($sp)
-/* 36C08 8005B808 27B20010 */  addiu     $s2, $sp, 0x10
-/* 36C0C 8005B80C 26300008 */  addiu     $s0, $s1, 8
-.L8005B810:
-/* 36C10 8005B810 02A0202D */  daddu     $a0, $s5, $zero
-/* 36C14 8005B814 0240302D */  daddu     $a2, $s2, $zero
-/* 36C18 8005B818 26730001 */  addiu     $s3, $s3, 1
-/* 36C1C 8005B81C 8E250000 */  lw        $a1, ($s1)
-/* 36C20 8005B820 0C016E68 */  jal       _add_hit_vert_to_buffer
-/* 36C24 8005B824 26310040 */   addiu    $s1, $s1, 0x40
-/* 36C28 8005B828 02A0202D */  daddu     $a0, $s5, $zero
-/* 36C2C 8005B82C 8E05FFFC */  lw        $a1, -4($s0)
-/* 36C30 8005B830 0C016E68 */  jal       _add_hit_vert_to_buffer
-/* 36C34 8005B834 0240302D */   daddu    $a2, $s2, $zero
-/* 36C38 8005B838 02A0202D */  daddu     $a0, $s5, $zero
-/* 36C3C 8005B83C 8E050000 */  lw        $a1, ($s0)
-/* 36C40 8005B840 0C016E68 */  jal       _add_hit_vert_to_buffer
-/* 36C44 8005B844 0240302D */   daddu    $a2, $s2, $zero
-/* 36C48 8005B848 8682000A */  lh        $v0, 0xa($s4)
-/* 36C4C 8005B84C 0262102A */  slt       $v0, $s3, $v0
-/* 36C50 8005B850 1440FFEF */  bnez      $v0, .L8005B810
-/* 36C54 8005B854 26100040 */   addiu    $s0, $s0, 0x40
-.L8005B858:
-/* 36C58 8005B858 8FA20010 */  lw        $v0, 0x10($sp)
-/* 36C5C 8005B85C 0000982D */  daddu     $s3, $zero, $zero
-/* 36C60 8005B860 00022040 */  sll       $a0, $v0, 1
-/* 36C64 8005B864 00822021 */  addu      $a0, $a0, $v0
-/* 36C68 8005B868 97A20012 */  lhu       $v0, 0x12($sp)
-/* 36C6C 8005B86C 000420C0 */  sll       $a0, $a0, 3
-/* 36C70 8005B870 0C00AB6C */  jal       collision_heap_malloc
-/* 36C74 8005B874 A6820014 */   sh       $v0, 0x14($s4)
-/* 36C78 8005B878 8FA30010 */  lw        $v1, 0x10($sp)
-/* 36C7C 8005B87C 0040902D */  daddu     $s2, $v0, $zero
-/* 36C80 8005B880 18600013 */  blez      $v1, .L8005B8D0
-/* 36C84 8005B884 AE920018 */   sw       $s2, 0x18($s4)
-/* 36C88 8005B888 0060202D */  daddu     $a0, $v1, $zero
-/* 36C8C 8005B88C 26430008 */  addiu     $v1, $s2, 8
-.L8005B890:
-/* 36C90 8005B890 8EC20000 */  lw        $v0, ($s6)
-/* 36C94 8005B894 26D60004 */  addiu     $s6, $s6, 4
-/* 36C98 8005B898 C4400000 */  lwc1      $f0, ($v0)
-/* 36C9C 8005B89C 26730001 */  addiu     $s3, $s3, 1
-/* 36CA0 8005B8A0 E4600004 */  swc1      $f0, 4($v1)
-/* 36CA4 8005B8A4 E6400000 */  swc1      $f0, ($s2)
-/* 36CA8 8005B8A8 C4400004 */  lwc1      $f0, 4($v0)
-/* 36CAC 8005B8AC 26520018 */  addiu     $s2, $s2, 0x18
-/* 36CB0 8005B8B0 E4600008 */  swc1      $f0, 8($v1)
-/* 36CB4 8005B8B4 E460FFFC */  swc1      $f0, -4($v1)
-/* 36CB8 8005B8B8 C4400008 */  lwc1      $f0, 8($v0)
-/* 36CBC 8005B8BC 0264102A */  slt       $v0, $s3, $a0
-/* 36CC0 8005B8C0 E460000C */  swc1      $f0, 0xc($v1)
-/* 36CC4 8005B8C4 E4600000 */  swc1      $f0, ($v1)
-/* 36CC8 8005B8C8 1440FFF1 */  bnez      $v0, .L8005B890
-/* 36CCC 8005B8CC 24630018 */   addiu    $v1, $v1, 0x18
-.L8005B8D0:
-/* 36CD0 8005B8D0 8E920018 */  lw        $s2, 0x18($s4)
-/* 36CD4 8005B8D4 8682000A */  lh        $v0, 0xa($s4)
-/* 36CD8 8005B8D8 8E91000C */  lw        $s1, 0xc($s4)
-/* 36CDC 8005B8DC 18400024 */  blez      $v0, .L8005B970
-/* 36CE0 8005B8E0 0000982D */   daddu    $s3, $zero, $zero
-/* 36CE4 8005B8E4 27B60010 */  addiu     $s6, $sp, 0x10
-/* 36CE8 8005B8E8 26300008 */  addiu     $s0, $s1, 8
-.L8005B8EC:
-/* 36CEC 8005B8EC 02A0202D */  daddu     $a0, $s5, $zero
-/* 36CF0 8005B8F0 02C0302D */  daddu     $a2, $s6, $zero
-/* 36CF4 8005B8F4 8E250000 */  lw        $a1, ($s1)
-/* 36CF8 8005B8F8 0C016E7D */  jal       _get_hit_vert_index_from_buffer
-/* 36CFC 8005B8FC 26730001 */   addiu    $s3, $s3, 1
-/* 36D00 8005B900 02A0202D */  daddu     $a0, $s5, $zero
-/* 36D04 8005B904 02C0302D */  daddu     $a2, $s6, $zero
-/* 36D08 8005B908 00021840 */  sll       $v1, $v0, 1
-/* 36D0C 8005B90C 00621821 */  addu      $v1, $v1, $v0
-/* 36D10 8005B910 000318C0 */  sll       $v1, $v1, 3
-/* 36D14 8005B914 02431821 */  addu      $v1, $s2, $v1
-/* 36D18 8005B918 AE230000 */  sw        $v1, ($s1)
-/* 36D1C 8005B91C 8E05FFFC */  lw        $a1, -4($s0)
-/* 36D20 8005B920 0C016E7D */  jal       _get_hit_vert_index_from_buffer
-/* 36D24 8005B924 26310040 */   addiu    $s1, $s1, 0x40
-/* 36D28 8005B928 02A0202D */  daddu     $a0, $s5, $zero
-/* 36D2C 8005B92C 02C0302D */  daddu     $a2, $s6, $zero
-/* 36D30 8005B930 00021840 */  sll       $v1, $v0, 1
-/* 36D34 8005B934 00621821 */  addu      $v1, $v1, $v0
-/* 36D38 8005B938 000318C0 */  sll       $v1, $v1, 3
-/* 36D3C 8005B93C 8E050000 */  lw        $a1, ($s0)
-/* 36D40 8005B940 02431821 */  addu      $v1, $s2, $v1
-/* 36D44 8005B944 0C016E7D */  jal       _get_hit_vert_index_from_buffer
-/* 36D48 8005B948 AE03FFFC */   sw       $v1, -4($s0)
-/* 36D4C 8005B94C 00021840 */  sll       $v1, $v0, 1
-/* 36D50 8005B950 00621821 */  addu      $v1, $v1, $v0
-/* 36D54 8005B954 000318C0 */  sll       $v1, $v1, 3
-/* 36D58 8005B958 02431821 */  addu      $v1, $s2, $v1
-/* 36D5C 8005B95C AE030000 */  sw        $v1, ($s0)
-/* 36D60 8005B960 8682000A */  lh        $v0, 0xa($s4)
-/* 36D64 8005B964 0262102A */  slt       $v0, $s3, $v0
-/* 36D68 8005B968 1440FFE0 */  bnez      $v0, .L8005B8EC
-/* 36D6C 8005B96C 26100040 */   addiu    $s0, $s0, 0x40
-.L8005B970:
-/* 36D70 8005B970 0C00AB7D */  jal       collision_heap_free
-/* 36D74 8005B974 02A0202D */   daddu    $a0, $s5, $zero
-/* 36D78 8005B978 8FBF0034 */  lw        $ra, 0x34($sp)
-/* 36D7C 8005B97C 8FB60030 */  lw        $s6, 0x30($sp)
-/* 36D80 8005B980 8FB5002C */  lw        $s5, 0x2c($sp)
-/* 36D84 8005B984 8FB40028 */  lw        $s4, 0x28($sp)
-/* 36D88 8005B988 8FB30024 */  lw        $s3, 0x24($sp)
-/* 36D8C 8005B98C 8FB20020 */  lw        $s2, 0x20($sp)
-/* 36D90 8005B990 8FB1001C */  lw        $s1, 0x1c($sp)
-/* 36D94 8005B994 8FB00018 */  lw        $s0, 0x18($sp)
-/* 36D98 8005B998 03E00008 */  jr        $ra
-/* 36D9C 8005B99C 27BD0038 */   addiu    $sp, $sp, 0x38
diff --git a/ver/us/asm/nonmatchings/362a0_len_2f70/test_down_ray_triangle.s b/ver/us/asm/nonmatchings/362a0_len_2f70/test_down_ray_triangle.s
deleted file mode 100644
index eb4ec509a2..0000000000
--- a/ver/us/asm/nonmatchings/362a0_len_2f70/test_down_ray_triangle.s
+++ /dev/null
@@ -1,204 +0,0 @@
-.set noat      # allow manual use of $at
-.set noreorder # don't insert nops after branches
-
-glabel test_down_ray_triangle
-/* 3789C 8005C49C C4800030 */  lwc1      $f0, 0x30($a0)
-/* 378A0 8005C4A0 44801000 */  mtc1      $zero, $f2
-/* 378A4 8005C4A4 00000000 */  nop
-/* 378A8 8005C4A8 46020032 */  c.eq.s    $f0, $f2
-/* 378AC 8005C4AC 00000000 */  nop
-/* 378B0 8005C4B0 4500000B */  bc1f      .L8005C4E0
-/* 378B4 8005C4B4 00000000 */   nop
-/* 378B8 8005C4B8 C4800034 */  lwc1      $f0, 0x34($a0)
-/* 378BC 8005C4BC 46020032 */  c.eq.s    $f0, $f2
-/* 378C0 8005C4C0 00000000 */  nop
-/* 378C4 8005C4C4 45000006 */  bc1f      .L8005C4E0
-/* 378C8 8005C4C8 00000000 */   nop
-/* 378CC 8005C4CC C4800038 */  lwc1      $f0, 0x38($a0)
-/* 378D0 8005C4D0 46020032 */  c.eq.s    $f0, $f2
-/* 378D4 8005C4D4 00000000 */  nop
-/* 378D8 8005C4D8 45010050 */  bc1t      .L8005C61C
-/* 378DC 8005C4DC 00000000 */   nop
-.L8005C4E0:
-/* 378E0 8005C4E0 8C820000 */  lw        $v0, ($a0)
-/* 378E4 8005C4E4 3C01800A */  lui       $at, %hi(D_800A4230)
-/* 378E8 8005C4E8 C4324230 */  lwc1      $f18, %lo(D_800A4230)($at)
-/* 378EC 8005C4EC C4400000 */  lwc1      $f0, ($v0)
-/* 378F0 8005C4F0 46009301 */  sub.s     $f12, $f18, $f0
-/* 378F4 8005C4F4 C4840030 */  lwc1      $f4, 0x30($a0)
-/* 378F8 8005C4F8 460C2102 */  mul.s     $f4, $f4, $f12
-/* 378FC 8005C4FC 00000000 */  nop
-/* 37900 8005C500 3C01800A */  lui       $at, %hi(D_800A4234)
-/* 37904 8005C504 C4224234 */  lwc1      $f2, %lo(D_800A4234)($at)
-/* 37908 8005C508 C4400004 */  lwc1      $f0, 4($v0)
-/* 3790C 8005C50C 46001081 */  sub.s     $f2, $f2, $f0
-/* 37910 8005C510 C4860034 */  lwc1      $f6, 0x34($a0)
-/* 37914 8005C514 46023082 */  mul.s     $f2, $f6, $f2
-/* 37918 8005C518 00000000 */  nop
-/* 3791C 8005C51C 3C01800A */  lui       $at, %hi(D_800A4238)
-/* 37920 8005C520 C42E4238 */  lwc1      $f14, %lo(D_800A4238)($at)
-/* 37924 8005C524 C4400008 */  lwc1      $f0, 8($v0)
-/* 37928 8005C528 46007201 */  sub.s     $f8, $f14, $f0
-/* 3792C 8005C52C C4800038 */  lwc1      $f0, 0x38($a0)
-/* 37930 8005C530 46080002 */  mul.s     $f0, $f0, $f8
-/* 37934 8005C534 00000000 */  nop
-/* 37938 8005C538 8C830004 */  lw        $v1, 4($a0)
-/* 3793C 8005C53C 46022100 */  add.s     $f4, $f4, $f2
-/* 37940 8005C540 8C850008 */  lw        $a1, 8($a0)
-/* 37944 8005C544 8482003C */  lh        $v0, 0x3c($a0)
-/* 37948 8005C548 10400036 */  beqz      $v0, .L8005C624
-/* 3794C 8005C54C 46002280 */   add.s    $f10, $f4, $f0
-/* 37950 8005C550 44808000 */  mtc1      $zero, $f16
-/* 37954 8005C554 00000000 */  nop
-/* 37958 8005C558 4610503C */  c.lt.s    $f10, $f16
-/* 3795C 8005C55C 00000000 */  nop
-/* 37960 8005C560 4501002E */  bc1t      .L8005C61C
-/* 37964 8005C564 00000000 */   nop
-/* 37968 8005C568 4610303E */  c.le.s    $f6, $f16
-/* 3796C 8005C56C 00000000 */  nop
-/* 37970 8005C570 4501002A */  bc1t      .L8005C61C
-/* 37974 8005C574 00000000 */   nop
-/* 37978 8005C578 C482000C */  lwc1      $f2, 0xc($a0)
-/* 3797C 8005C57C 46024082 */  mul.s     $f2, $f8, $f2
-/* 37980 8005C580 00000000 */  nop
-/* 37984 8005C584 C4800014 */  lwc1      $f0, 0x14($a0)
-/* 37988 8005C588 46006002 */  mul.s     $f0, $f12, $f0
-/* 3798C 8005C58C 00000000 */  nop
-/* 37990 8005C590 46001081 */  sub.s     $f2, $f2, $f0
-/* 37994 8005C594 4610103C */  c.lt.s    $f2, $f16
-/* 37998 8005C598 00000000 */  nop
-/* 3799C 8005C59C 4501001F */  bc1t      .L8005C61C
-/* 379A0 8005C5A0 00000000 */   nop
-/* 379A4 8005C5A4 C4620008 */  lwc1      $f2, 8($v1)
-/* 379A8 8005C5A8 46027081 */  sub.s     $f2, $f14, $f2
-/* 379AC 8005C5AC C4800018 */  lwc1      $f0, 0x18($a0)
-/* 379B0 8005C5B0 46001082 */  mul.s     $f2, $f2, $f0
-/* 379B4 8005C5B4 00000000 */  nop
-/* 379B8 8005C5B8 C4600000 */  lwc1      $f0, ($v1)
-/* 379BC 8005C5BC 46009001 */  sub.s     $f0, $f18, $f0
-/* 379C0 8005C5C0 C4840020 */  lwc1      $f4, 0x20($a0)
-/* 379C4 8005C5C4 46040002 */  mul.s     $f0, $f0, $f4
-/* 379C8 8005C5C8 00000000 */  nop
-/* 379CC 8005C5CC 46001081 */  sub.s     $f2, $f2, $f0
-/* 379D0 8005C5D0 4610103C */  c.lt.s    $f2, $f16
-/* 379D4 8005C5D4 00000000 */  nop
-/* 379D8 8005C5D8 45010010 */  bc1t      .L8005C61C
-/* 379DC 8005C5DC 00000000 */   nop
-/* 379E0 8005C5E0 C4A20008 */  lwc1      $f2, 8($a1)
-/* 379E4 8005C5E4 46027081 */  sub.s     $f2, $f14, $f2
-/* 379E8 8005C5E8 C4800024 */  lwc1      $f0, 0x24($a0)
-/* 379EC 8005C5EC 46001082 */  mul.s     $f2, $f2, $f0
-/* 379F0 8005C5F0 00000000 */  nop
-/* 379F4 8005C5F4 C4A00000 */  lwc1      $f0, ($a1)
-/* 379F8 8005C5F8 46009001 */  sub.s     $f0, $f18, $f0
-/* 379FC 8005C5FC C484002C */  lwc1      $f4, 0x2c($a0)
-/* 37A00 8005C600 46040002 */  mul.s     $f0, $f0, $f4
-/* 37A04 8005C604 00000000 */  nop
-/* 37A08 8005C608 46001081 */  sub.s     $f2, $f2, $f0
-/* 37A0C 8005C60C 4610103C */  c.lt.s    $f2, $f16
-/* 37A10 8005C610 00000000 */  nop
-.L8005C614:
-/* 37A14 8005C614 45000039 */  bc1f      .L8005C6FC
-/* 37A18 8005C618 00000000 */   nop
-.L8005C61C:
-/* 37A1C 8005C61C 03E00008 */  jr        $ra
-/* 37A20 8005C620 0000102D */   daddu    $v0, $zero, $zero
-.L8005C624:
-/* 37A24 8005C624 460A3002 */  mul.s     $f0, $f6, $f10
-/* 37A28 8005C628 00000000 */  nop
-/* 37A2C 8005C62C 44803000 */  mtc1      $zero, $f6
-/* 37A30 8005C630 00000000 */  nop
-/* 37A34 8005C634 4606003E */  c.le.s    $f0, $f6
-/* 37A38 8005C638 00000000 */  nop
-/* 37A3C 8005C63C 4501FFF7 */  bc1t      .L8005C61C
-/* 37A40 8005C640 00000000 */   nop
-/* 37A44 8005C644 C480000C */  lwc1      $f0, 0xc($a0)
-/* 37A48 8005C648 46004002 */  mul.s     $f0, $f8, $f0
-/* 37A4C 8005C64C 00000000 */  nop
-/* 37A50 8005C650 C4820014 */  lwc1      $f2, 0x14($a0)
-/* 37A54 8005C654 46026082 */  mul.s     $f2, $f12, $f2
-/* 37A58 8005C658 00000000 */  nop
-/* 37A5C 8005C65C 46020001 */  sub.s     $f0, $f0, $f2
-/* 37A60 8005C660 460A0002 */  mul.s     $f0, $f0, $f10
-/* 37A64 8005C664 00000000 */  nop
-/* 37A68 8005C668 4606003C */  c.lt.s    $f0, $f6
-/* 37A6C 8005C66C 00000000 */  nop
-/* 37A70 8005C670 4501FFEA */  bc1t      .L8005C61C
-/* 37A74 8005C674 00000000 */   nop
-/* 37A78 8005C678 C4600008 */  lwc1      $f0, 8($v1)
-/* 37A7C 8005C67C 46007001 */  sub.s     $f0, $f14, $f0
-/* 37A80 8005C680 C4820018 */  lwc1      $f2, 0x18($a0)
-/* 37A84 8005C684 46020002 */  mul.s     $f0, $f0, $f2
-/* 37A88 8005C688 00000000 */  nop
-/* 37A8C 8005C68C C4620000 */  lwc1      $f2, ($v1)
-/* 37A90 8005C690 46029081 */  sub.s     $f2, $f18, $f2
-/* 37A94 8005C694 C4840020 */  lwc1      $f4, 0x20($a0)
-/* 37A98 8005C698 46041082 */  mul.s     $f2, $f2, $f4
-/* 37A9C 8005C69C 00000000 */  nop
-/* 37AA0 8005C6A0 46020001 */  sub.s     $f0, $f0, $f2
-/* 37AA4 8005C6A4 460A0002 */  mul.s     $f0, $f0, $f10
-/* 37AA8 8005C6A8 00000000 */  nop
-/* 37AAC 8005C6AC 4606003C */  c.lt.s    $f0, $f6
-/* 37AB0 8005C6B0 00000000 */  nop
-/* 37AB4 8005C6B4 4501FFD9 */  bc1t      .L8005C61C
-/* 37AB8 8005C6B8 00000000 */   nop
-/* 37ABC 8005C6BC C4A00008 */  lwc1      $f0, 8($a1)
-/* 37AC0 8005C6C0 46007001 */  sub.s     $f0, $f14, $f0
-/* 37AC4 8005C6C4 C4820024 */  lwc1      $f2, 0x24($a0)
-/* 37AC8 8005C6C8 46020002 */  mul.s     $f0, $f0, $f2
-/* 37ACC 8005C6CC 00000000 */  nop
-/* 37AD0 8005C6D0 C4A20000 */  lwc1      $f2, ($a1)
-/* 37AD4 8005C6D4 46029081 */  sub.s     $f2, $f18, $f2
-/* 37AD8 8005C6D8 C484002C */  lwc1      $f4, 0x2c($a0)
-/* 37ADC 8005C6DC 46041082 */  mul.s     $f2, $f2, $f4
-/* 37AE0 8005C6E0 00000000 */  nop
-/* 37AE4 8005C6E4 46020001 */  sub.s     $f0, $f0, $f2
-/* 37AE8 8005C6E8 460A0002 */  mul.s     $f0, $f0, $f10
-/* 37AEC 8005C6EC 00000000 */  nop
-/* 37AF0 8005C6F0 4606003C */  c.lt.s    $f0, $f6
-/* 37AF4 8005C6F4 08017185 */  j         .L8005C614
-/* 37AF8 8005C6F8 00000000 */   nop
-.L8005C6FC:
-/* 37AFC 8005C6FC 3C01800A */  lui       $at, %hi(D_800A4254)
-/* 37B00 8005C700 C4244254 */  lwc1      $f4, %lo(D_800A4254)($at)
-/* 37B04 8005C704 44800000 */  mtc1      $zero, $f0
-/* 37B08 8005C708 C4820034 */  lwc1      $f2, 0x34($a0)
-/* 37B0C 8005C70C 4604003E */  c.le.s    $f0, $f4
-/* 37B10 8005C710 00000000 */  nop
-/* 37B14 8005C714 45000007 */  bc1f      .L8005C734
-/* 37B18 8005C718 46001207 */   neg.s    $f8, $f2
-/* 37B1C 8005C71C 46005007 */  neg.s     $f0, $f10
-/* 37B20 8005C720 46080003 */  div.s     $f0, $f0, $f8
-/* 37B24 8005C724 4600203E */  c.le.s    $f4, $f0
-/* 37B28 8005C728 00000000 */  nop
-/* 37B2C 8005C72C 4501FFBB */  bc1t      .L8005C61C
-/* 37B30 8005C730 00000000 */   nop
-.L8005C734:
-/* 37B34 8005C734 3C01800A */  lui       $at, %hi(D_800A4230)
-/* 37B38 8005C738 C4204230 */  lwc1      $f0, %lo(D_800A4230)($at)
-/* 37B3C 8005C73C 3C01800A */  lui       $at, %hi(D_800A4238)
-/* 37B40 8005C740 C4244238 */  lwc1      $f4, %lo(D_800A4238)($at)
-/* 37B44 8005C744 C4860030 */  lwc1      $f6, 0x30($a0)
-/* 37B48 8005C748 3C01800A */  lui       $at, %hi(D_800A4248)
-/* 37B4C 8005C74C E4204248 */  swc1      $f0, %lo(D_800A4248)($at)
-/* 37B50 8005C750 3C01800A */  lui       $at, %hi(D_800A4234)
-/* 37B54 8005C754 C4204234 */  lwc1      $f0, %lo(D_800A4234)($at)
-/* 37B58 8005C758 46005087 */  neg.s     $f2, $f10
-/* 37B5C 8005C75C 3C01800A */  lui       $at, %hi(D_800A4250)
-/* 37B60 8005C760 E4244250 */  swc1      $f4, %lo(D_800A4250)($at)
-/* 37B64 8005C764 C4840034 */  lwc1      $f4, 0x34($a0)
-/* 37B68 8005C768 46081083 */  div.s     $f2, $f2, $f8
-/* 37B6C 8005C76C 3C01800A */  lui       $at, %hi(D_800A4254)
-/* 37B70 8005C770 E4224254 */  swc1      $f2, %lo(D_800A4254)($at)
-/* 37B74 8005C774 3C01800A */  lui       $at, %hi(D_800A4258)
-/* 37B78 8005C778 E4264258 */  swc1      $f6, %lo(D_800A4258)($at)
-/* 37B7C 8005C77C C4860038 */  lwc1      $f6, 0x38($a0)
-/* 37B80 8005C780 46020001 */  sub.s     $f0, $f0, $f2
-/* 37B84 8005C784 3C01800A */  lui       $at, %hi(D_800A425C)
-/* 37B88 8005C788 E424425C */  swc1      $f4, %lo(D_800A425C)($at)
-/* 37B8C 8005C78C 3C01800A */  lui       $at, %hi(D_800A4260)
-/* 37B90 8005C790 E4264260 */  swc1      $f6, %lo(D_800A4260)($at)
-/* 37B94 8005C794 3C01800A */  lui       $at, %hi(D_800A424C)
-/* 37B98 8005C798 E420424C */  swc1      $f0, %lo(D_800A424C)($at)
-/* 37B9C 8005C79C 03E00008 */  jr        $ra
-/* 37BA0 8005C7A0 24020001 */   addiu    $v0, $zero, 1
diff --git a/ver/us/asm/nonmatchings/362a0_len_2f70/test_ray_colliders.s b/ver/us/asm/nonmatchings/362a0_len_2f70/test_ray_colliders.s
deleted file mode 100644
index c5aefc0664..0000000000
--- a/ver/us/asm/nonmatchings/362a0_len_2f70/test_ray_colliders.s
+++ /dev/null
@@ -1,301 +0,0 @@
-.set noat      # allow manual use of $at
-.set noreorder # don't insert nops after branches
-
-glabel test_ray_colliders
-/* 380D0 8005CCD0 27BDFF98 */  addiu     $sp, $sp, -0x68
-/* 380D4 8005CCD4 44854000 */  mtc1      $a1, $f8
-/* 380D8 8005CCD8 44866000 */  mtc1      $a2, $f12
-/* 380DC 8005CCDC 44877000 */  mtc1      $a3, $f14
-/* 380E0 8005CCE0 C7A40078 */  lwc1      $f4, 0x78($sp)
-/* 380E4 8005CCE4 44800000 */  mtc1      $zero, $f0
-/* 380E8 8005CCE8 C7A6007C */  lwc1      $f6, 0x7c($sp)
-/* 380EC 8005CCEC C7AA0080 */  lwc1      $f10, 0x80($sp)
-/* 380F0 8005CCF0 AFBE0030 */  sw        $fp, 0x30($sp)
-/* 380F4 8005CCF4 8FBE0090 */  lw        $fp, 0x90($sp)
-/* 380F8 8005CCF8 AFB7002C */  sw        $s7, 0x2c($sp)
-/* 380FC 8005CCFC AFBF0034 */  sw        $ra, 0x34($sp)
-/* 38100 8005CD00 AFB60028 */  sw        $s6, 0x28($sp)
-/* 38104 8005CD04 AFB50024 */  sw        $s5, 0x24($sp)
-/* 38108 8005CD08 AFB40020 */  sw        $s4, 0x20($sp)
-/* 3810C 8005CD0C AFB3001C */  sw        $s3, 0x1c($sp)
-/* 38110 8005CD10 AFB20018 */  sw        $s2, 0x18($sp)
-/* 38114 8005CD14 AFB10014 */  sw        $s1, 0x14($sp)
-/* 38118 8005CD18 AFB00010 */  sw        $s0, 0x10($sp)
-/* 3811C 8005CD1C F7BE0060 */  sdc1      $f30, 0x60($sp)
-/* 38120 8005CD20 F7BC0058 */  sdc1      $f28, 0x58($sp)
-/* 38124 8005CD24 F7BA0050 */  sdc1      $f26, 0x50($sp)
-/* 38128 8005CD28 F7B80048 */  sdc1      $f24, 0x48($sp)
-/* 3812C 8005CD2C F7B60040 */  sdc1      $f22, 0x40($sp)
-/* 38130 8005CD30 F7B40038 */  sdc1      $f20, 0x38($sp)
-/* 38134 8005CD34 46002032 */  c.eq.s    $f4, $f0
-/* 38138 8005CD38 00000000 */  nop
-/* 3813C 8005CD3C 45000009 */  bc1f      .L8005CD64
-/* 38140 8005CD40 0080B82D */   daddu    $s7, $a0, $zero
-/* 38144 8005CD44 46003032 */  c.eq.s    $f6, $f0
-/* 38148 8005CD48 00000000 */  nop
-/* 3814C 8005CD4C 45000005 */  bc1f      .L8005CD64
-/* 38150 8005CD50 00000000 */   nop
-/* 38154 8005CD54 46005032 */  c.eq.s    $f10, $f0
-/* 38158 8005CD58 00000000 */  nop
-/* 3815C 8005CD5C 450100DF */  bc1t      .L8005D0DC
-/* 38160 8005CD60 0000102D */   daddu    $v0, $zero, $zero
-.L8005CD64:
-/* 38164 8005CD64 3C15800B */  lui       $s5, %hi(gCollisionData)
-/* 38168 8005CD68 26B542E0 */  addiu     $s5, $s5, %lo(gCollisionData)
-/* 3816C 8005CD6C 3C01800A */  lui       $at, %hi(D_800A423C)
-/* 38170 8005CD70 E424423C */  swc1      $f4, %lo(D_800A423C)($at)
-/* 38174 8005CD74 3C01800A */  lui       $at, %hi(D_800A4240)
-/* 38178 8005CD78 E4264240 */  swc1      $f6, %lo(D_800A4240)($at)
-/* 3817C 8005CD7C 3C01800A */  lui       $at, %hi(D_800A4244)
-/* 38180 8005CD80 E42A4244 */  swc1      $f10, %lo(D_800A4244)($at)
-/* 38184 8005CD84 3C01800A */  lui       $at, %hi(D_800A4230)
-/* 38188 8005CD88 E4284230 */  swc1      $f8, %lo(D_800A4230)($at)
-/* 3818C 8005CD8C 3C01800A */  lui       $at, %hi(D_800A4234)
-/* 38190 8005CD90 E42C4234 */  swc1      $f12, %lo(D_800A4234)($at)
-/* 38194 8005CD94 3C01800A */  lui       $at, %hi(D_800A4238)
-/* 38198 8005CD98 E42E4238 */  swc1      $f14, %lo(D_800A4238)($at)
-/* 3819C 8005CD9C C7C20000 */  lwc1      $f2, ($fp)
-/* 381A0 8005CDA0 4600203C */  c.lt.s    $f4, $f0
-/* 381A4 8005CDA4 3C01800A */  lui       $at, %hi(D_800A4254)
-/* 381A8 8005CDA8 E4224254 */  swc1      $f2, %lo(D_800A4254)($at)
-/* 381AC 8005CDAC 45000006 */  bc1f      .L8005CDC8
-/* 381B0 8005CDB0 2414FFFF */   addiu    $s4, $zero, -1
-/* 381B4 8005CDB4 46022002 */  mul.s     $f0, $f4, $f2
-/* 381B8 8005CDB8 00000000 */  nop
-/* 381BC 8005CDBC 46004786 */  mov.s     $f30, $f8
-/* 381C0 8005CDC0 08017376 */  j         .L8005CDD8
-/* 381C4 8005CDC4 4600F700 */   add.s    $f28, $f30, $f0
-.L8005CDC8:
-/* 381C8 8005CDC8 46022002 */  mul.s     $f0, $f4, $f2
-/* 381CC 8005CDCC 00000000 */  nop
-/* 381D0 8005CDD0 46004706 */  mov.s     $f28, $f8
-/* 381D4 8005CDD4 4600E780 */  add.s     $f30, $f28, $f0
-.L8005CDD8:
-/* 381D8 8005CDD8 44800000 */  mtc1      $zero, $f0
-/* 381DC 8005CDDC 00000000 */  nop
-/* 381E0 8005CDE0 4600303C */  c.lt.s    $f6, $f0
-/* 381E4 8005CDE4 00000000 */  nop
-/* 381E8 8005CDE8 45000007 */  bc1f      .L8005CE08
-/* 381EC 8005CDEC 46006686 */   mov.s    $f26, $f12
-/* 381F0 8005CDF0 3C01800A */  lui       $at, %hi(D_800A4254)
-/* 381F4 8005CDF4 C4204254 */  lwc1      $f0, %lo(D_800A4254)($at)
-/* 381F8 8005CDF8 46003002 */  mul.s     $f0, $f6, $f0
-/* 381FC 8005CDFC 00000000 */  nop
-/* 38200 8005CE00 08017388 */  j         .L8005CE20
-/* 38204 8005CE04 4600D600 */   add.s    $f24, $f26, $f0
-.L8005CE08:
-/* 38208 8005CE08 3C01800A */  lui       $at, %hi(D_800A4254)
-/* 3820C 8005CE0C C4204254 */  lwc1      $f0, %lo(D_800A4254)($at)
-/* 38210 8005CE10 46003002 */  mul.s     $f0, $f6, $f0
-/* 38214 8005CE14 00000000 */  nop
-/* 38218 8005CE18 46006606 */  mov.s     $f24, $f12
-/* 3821C 8005CE1C 4600C680 */  add.s     $f26, $f24, $f0
-.L8005CE20:
-/* 38220 8005CE20 44800000 */  mtc1      $zero, $f0
-/* 38224 8005CE24 00000000 */  nop
-/* 38228 8005CE28 4600503C */  c.lt.s    $f10, $f0
-/* 3822C 8005CE2C 00000000 */  nop
-/* 38230 8005CE30 45000007 */  bc1f      .L8005CE50
-/* 38234 8005CE34 46007586 */   mov.s    $f22, $f14
-/* 38238 8005CE38 3C01800A */  lui       $at, %hi(D_800A4254)
-/* 3823C 8005CE3C C4204254 */  lwc1      $f0, %lo(D_800A4254)($at)
-/* 38240 8005CE40 46005002 */  mul.s     $f0, $f10, $f0
-/* 38244 8005CE44 00000000 */  nop
-/* 38248 8005CE48 0801739A */  j         .L8005CE68
-/* 3824C 8005CE4C 4600B500 */   add.s    $f20, $f22, $f0
-.L8005CE50:
-/* 38250 8005CE50 3C01800A */  lui       $at, %hi(D_800A4254)
-/* 38254 8005CE54 C4204254 */  lwc1      $f0, %lo(D_800A4254)($at)
-/* 38258 8005CE58 46005002 */  mul.s     $f0, $f10, $f0
-/* 3825C 8005CE5C 00000000 */  nop
-/* 38260 8005CE60 46007506 */  mov.s     $f20, $f14
-/* 38264 8005CE64 4600A580 */  add.s     $f22, $f20, $f0
-.L8005CE68:
-/* 38268 8005CE68 86A2000C */  lh        $v0, 0xc($s5)
-/* 3826C 8005CE6C 1840007D */  blez      $v0, .L8005D064
-/* 38270 8005CE70 0000982D */   daddu    $s3, $zero, $zero
-/* 38274 8005CE74 0260B02D */  daddu     $s6, $s3, $zero
-.L8005CE78:
-/* 38278 8005CE78 8EA20004 */  lw        $v0, 4($s5)
-/* 3827C 8005CE7C 00569021 */  addu      $s2, $v0, $s6
-/* 38280 8005CE80 8E420000 */  lw        $v0, ($s2)
-/* 38284 8005CE84 00571024 */  and       $v0, $v0, $s7
-/* 38288 8005CE88 54400071 */  bnel      $v0, $zero, .L8005D050
-/* 3828C 8005CE8C 26D6001C */   addiu    $s6, $s6, 0x1c
-/* 38290 8005CE90 8643000A */  lh        $v1, 0xa($s2)
-/* 38294 8005CE94 5060006E */  beql      $v1, $zero, .L8005D050
-/* 38298 8005CE98 26D6001C */   addiu    $s6, $s6, 0x1c
-/* 3829C 8005CE9C 8E420010 */  lw        $v0, 0x10($s2)
-/* 382A0 8005CEA0 C4400000 */  lwc1      $f0, ($v0)
-/* 382A4 8005CEA4 4600F03C */  c.lt.s    $f30, $f0
-/* 382A8 8005CEA8 00000000 */  nop
-/* 382AC 8005CEAC 45030068 */  bc1tl     .L8005D050
-/* 382B0 8005CEB0 26D6001C */   addiu    $s6, $s6, 0x1c
-/* 382B4 8005CEB4 C440000C */  lwc1      $f0, 0xc($v0)
-/* 382B8 8005CEB8 461C003C */  c.lt.s    $f0, $f28
-/* 382BC 8005CEBC 00000000 */  nop
-/* 382C0 8005CEC0 45030063 */  bc1tl     .L8005D050
-/* 382C4 8005CEC4 26D6001C */   addiu    $s6, $s6, 0x1c
-/* 382C8 8005CEC8 C4400008 */  lwc1      $f0, 8($v0)
-/* 382CC 8005CECC 4600B03C */  c.lt.s    $f22, $f0
-/* 382D0 8005CED0 00000000 */  nop
-/* 382D4 8005CED4 4503005E */  bc1tl     .L8005D050
-/* 382D8 8005CED8 26D6001C */   addiu    $s6, $s6, 0x1c
-/* 382DC 8005CEDC C4400014 */  lwc1      $f0, 0x14($v0)
-/* 382E0 8005CEE0 4614003C */  c.lt.s    $f0, $f20
-/* 382E4 8005CEE4 00000000 */  nop
-/* 382E8 8005CEE8 45030059 */  bc1tl     .L8005D050
-/* 382EC 8005CEEC 26D6001C */   addiu    $s6, $s6, 0x1c
-/* 382F0 8005CEF0 C4400004 */  lwc1      $f0, 4($v0)
-/* 382F4 8005CEF4 4600D03C */  c.lt.s    $f26, $f0
-/* 382F8 8005CEF8 00000000 */  nop
-/* 382FC 8005CEFC 45030054 */  bc1tl     .L8005D050
-/* 38300 8005CF00 26D6001C */   addiu    $s6, $s6, 0x1c
-/* 38304 8005CF04 C4400010 */  lwc1      $f0, 0x10($v0)
-/* 38308 8005CF08 4618003C */  c.lt.s    $f0, $f24
-/* 3830C 8005CF0C 00000000 */  nop
-/* 38310 8005CF10 4503004F */  bc1tl     .L8005D050
-/* 38314 8005CF14 26D6001C */   addiu    $s6, $s6, 0x1c
-/* 38318 8005CF18 3C01800A */  lui       $at, %hi(D_800A423C)
-/* 3831C 8005CF1C C420423C */  lwc1      $f0, %lo(D_800A423C)($at)
-/* 38320 8005CF20 44808000 */  mtc1      $zero, $f16
-/* 38324 8005CF24 8E51000C */  lw        $s1, 0xc($s2)
-/* 38328 8005CF28 46100032 */  c.eq.s    $f0, $f16
-/* 3832C 8005CF2C 00000000 */  nop
-/* 38330 8005CF30 45000020 */  bc1f      .L8005CFB4
-/* 38334 8005CF34 00000000 */   nop
-/* 38338 8005CF38 3C01800A */  lui       $at, %hi(D_800A4244)
-/* 3833C 8005CF3C C4204244 */  lwc1      $f0, %lo(D_800A4244)($at)
-/* 38340 8005CF40 46100032 */  c.eq.s    $f0, $f16
-/* 38344 8005CF44 00000000 */  nop
-/* 38348 8005CF48 4500001A */  bc1f      .L8005CFB4
-/* 3834C 8005CF4C 00000000 */   nop
-/* 38350 8005CF50 3C01800A */  lui       $at, %hi(D_800A4240)
-/* 38354 8005CF54 C4204240 */  lwc1      $f0, %lo(D_800A4240)($at)
-/* 38358 8005CF58 3C01BFF0 */  lui       $at, 0xbff0
-/* 3835C 8005CF5C 44811800 */  mtc1      $at, $f3
-/* 38360 8005CF60 44801000 */  mtc1      $zero, $f2
-/* 38364 8005CF64 46000021 */  cvt.d.s   $f0, $f0
-/* 38368 8005CF68 46220032 */  c.eq.d    $f0, $f2
-/* 3836C 8005CF6C 00000000 */  nop
-/* 38370 8005CF70 45000010 */  bc1f      .L8005CFB4
-/* 38374 8005CF74 00000000 */   nop
-/* 38378 8005CF78 18600034 */  blez      $v1, .L8005D04C
-/* 3837C 8005CF7C 0000802D */   daddu    $s0, $zero, $zero
-/* 38380 8005CF80 0220202D */  daddu     $a0, $s1, $zero
-.L8005CF84:
-/* 38384 8005CF84 8EA50000 */  lw        $a1, ($s5)
-/* 38388 8005CF88 0C017127 */  jal       test_down_ray_triangle
-/* 3838C 8005CF8C 26310040 */   addiu    $s1, $s1, 0x40
-/* 38390 8005CF90 54400001 */  bnel      $v0, $zero, .L8005CF98
-/* 38394 8005CF94 0260A02D */   daddu    $s4, $s3, $zero
-.L8005CF98:
-/* 38398 8005CF98 8642000A */  lh        $v0, 0xa($s2)
-/* 3839C 8005CF9C 26100001 */  addiu     $s0, $s0, 1
-/* 383A0 8005CFA0 0202102A */  slt       $v0, $s0, $v0
-/* 383A4 8005CFA4 1440FFF7 */  bnez      $v0, .L8005CF84
-/* 383A8 8005CFA8 0220202D */   daddu    $a0, $s1, $zero
-/* 383AC 8005CFAC 08017414 */  j         .L8005D050
-/* 383B0 8005CFB0 26D6001C */   addiu    $s6, $s6, 0x1c
-.L8005CFB4:
-/* 383B4 8005CFB4 3C01800A */  lui       $at, %hi(D_800A4240)
-/* 383B8 8005CFB8 C4204240 */  lwc1      $f0, %lo(D_800A4240)($at)
-/* 383BC 8005CFBC 44808000 */  mtc1      $zero, $f16
-/* 383C0 8005CFC0 00000000 */  nop
-/* 383C4 8005CFC4 46100032 */  c.eq.s    $f0, $f16
-/* 383C8 8005CFC8 00000000 */  nop
-/* 383CC 8005CFCC 45000011 */  bc1f      .L8005D014
-/* 383D0 8005CFD0 00000000 */   nop
-/* 383D4 8005CFD4 8642000A */  lh        $v0, 0xa($s2)
-/* 383D8 8005CFD8 1840001C */  blez      $v0, .L8005D04C
-/* 383DC 8005CFDC 0000802D */   daddu    $s0, $zero, $zero
-/* 383E0 8005CFE0 0220202D */  daddu     $a0, $s1, $zero
-.L8005CFE4:
-/* 383E4 8005CFE4 8EA50000 */  lw        $a1, ($s5)
-/* 383E8 8005CFE8 0C0171E9 */  jal       test_up_ray_triangle
-/* 383EC 8005CFEC 26310040 */   addiu    $s1, $s1, 0x40
-/* 383F0 8005CFF0 54400001 */  bnel      $v0, $zero, .L8005CFF8
-/* 383F4 8005CFF4 0260A02D */   daddu    $s4, $s3, $zero
-.L8005CFF8:
-/* 383F8 8005CFF8 8642000A */  lh        $v0, 0xa($s2)
-/* 383FC 8005CFFC 26100001 */  addiu     $s0, $s0, 1
-/* 38400 8005D000 0202102A */  slt       $v0, $s0, $v0
-/* 38404 8005D004 1440FFF7 */  bnez      $v0, .L8005CFE4
-/* 38408 8005D008 0220202D */   daddu    $a0, $s1, $zero
-/* 3840C 8005D00C 08017414 */  j         .L8005D050
-/* 38410 8005D010 26D6001C */   addiu    $s6, $s6, 0x1c
-.L8005D014:
-/* 38414 8005D014 8642000A */  lh        $v0, 0xa($s2)
-/* 38418 8005D018 1840000C */  blez      $v0, .L8005D04C
-/* 3841C 8005D01C 0000802D */   daddu    $s0, $zero, $zero
-/* 38420 8005D020 0220202D */  daddu     $a0, $s1, $zero
-.L8005D024:
-/* 38424 8005D024 8EA50000 */  lw        $a1, ($s5)
-/* 38428 8005D028 0C016FA1 */  jal       test_ray_triangle_general
-/* 3842C 8005D02C 26310040 */   addiu    $s1, $s1, 0x40
-/* 38430 8005D030 54400001 */  bnel      $v0, $zero, .L8005D038
-/* 38434 8005D034 0260A02D */   daddu    $s4, $s3, $zero
-.L8005D038:
-/* 38438 8005D038 8642000A */  lh        $v0, 0xa($s2)
-/* 3843C 8005D03C 26100001 */  addiu     $s0, $s0, 1
-/* 38440 8005D040 0202102A */  slt       $v0, $s0, $v0
-/* 38444 8005D044 1440FFF7 */  bnez      $v0, .L8005D024
-/* 38448 8005D048 0220202D */   daddu    $a0, $s1, $zero
-.L8005D04C:
-/* 3844C 8005D04C 26D6001C */  addiu     $s6, $s6, 0x1c
-.L8005D050:
-/* 38450 8005D050 86A2000C */  lh        $v0, 0xc($s5)
-/* 38454 8005D054 26730001 */  addiu     $s3, $s3, 1
-/* 38458 8005D058 0262102A */  slt       $v0, $s3, $v0
-/* 3845C 8005D05C 1440FF86 */  bnez      $v0, .L8005CE78
-/* 38460 8005D060 00000000 */   nop
-.L8005D064:
-/* 38464 8005D064 0680001D */  bltz      $s4, .L8005D0DC
-/* 38468 8005D068 0280102D */   daddu    $v0, $s4, $zero
-/* 3846C 8005D06C 3C01800A */  lui       $at, %hi(D_800A4248)
-/* 38470 8005D070 C4204248 */  lwc1      $f0, %lo(D_800A4248)($at)
-/* 38474 8005D074 8FA20084 */  lw        $v0, 0x84($sp)
-/* 38478 8005D078 E4400000 */  swc1      $f0, ($v0)
-/* 3847C 8005D07C 3C01800A */  lui       $at, %hi(D_800A424C)
-/* 38480 8005D080 C420424C */  lwc1      $f0, %lo(D_800A424C)($at)
-/* 38484 8005D084 8FA20088 */  lw        $v0, 0x88($sp)
-/* 38488 8005D088 E4400000 */  swc1      $f0, ($v0)
-/* 3848C 8005D08C 3C01800A */  lui       $at, %hi(D_800A4250)
-/* 38490 8005D090 C4204250 */  lwc1      $f0, %lo(D_800A4250)($at)
-/* 38494 8005D094 8FA2008C */  lw        $v0, 0x8c($sp)
-/* 38498 8005D098 E4400000 */  swc1      $f0, ($v0)
-/* 3849C 8005D09C 3C01800A */  lui       $at, %hi(D_800A4254)
-/* 384A0 8005D0A0 C4204254 */  lwc1      $f0, %lo(D_800A4254)($at)
-/* 384A4 8005D0A4 E7C00000 */  swc1      $f0, ($fp)
-/* 384A8 8005D0A8 3C01800A */  lui       $at, %hi(D_800A4258)
-/* 384AC 8005D0AC C4204258 */  lwc1      $f0, %lo(D_800A4258)($at)
-/* 384B0 8005D0B0 8FA20094 */  lw        $v0, 0x94($sp)
-/* 384B4 8005D0B4 E4400000 */  swc1      $f0, ($v0)
-/* 384B8 8005D0B8 3C01800A */  lui       $at, %hi(D_800A425C)
-/* 384BC 8005D0BC C420425C */  lwc1      $f0, %lo(D_800A425C)($at)
-/* 384C0 8005D0C0 8FA20098 */  lw        $v0, 0x98($sp)
-/* 384C4 8005D0C4 E4400000 */  swc1      $f0, ($v0)
-/* 384C8 8005D0C8 3C01800A */  lui       $at, %hi(D_800A4260)
-/* 384CC 8005D0CC C4204260 */  lwc1      $f0, %lo(D_800A4260)($at)
-/* 384D0 8005D0D0 8FA3009C */  lw        $v1, 0x9c($sp)
-/* 384D4 8005D0D4 0280102D */  daddu     $v0, $s4, $zero
-/* 384D8 8005D0D8 E4600000 */  swc1      $f0, ($v1)
-.L8005D0DC:
-/* 384DC 8005D0DC 8FBF0034 */  lw        $ra, 0x34($sp)
-/* 384E0 8005D0E0 8FBE0030 */  lw        $fp, 0x30($sp)
-/* 384E4 8005D0E4 8FB7002C */  lw        $s7, 0x2c($sp)
-/* 384E8 8005D0E8 8FB60028 */  lw        $s6, 0x28($sp)
-/* 384EC 8005D0EC 8FB50024 */  lw        $s5, 0x24($sp)
-/* 384F0 8005D0F0 8FB40020 */  lw        $s4, 0x20($sp)
-/* 384F4 8005D0F4 8FB3001C */  lw        $s3, 0x1c($sp)
-/* 384F8 8005D0F8 8FB20018 */  lw        $s2, 0x18($sp)
-/* 384FC 8005D0FC 8FB10014 */  lw        $s1, 0x14($sp)
-/* 38500 8005D100 8FB00010 */  lw        $s0, 0x10($sp)
-/* 38504 8005D104 D7BE0060 */  ldc1      $f30, 0x60($sp)
-/* 38508 8005D108 D7BC0058 */  ldc1      $f28, 0x58($sp)
-/* 3850C 8005D10C D7BA0050 */  ldc1      $f26, 0x50($sp)
-/* 38510 8005D110 D7B80048 */  ldc1      $f24, 0x48($sp)
-/* 38514 8005D114 D7B60040 */  ldc1      $f22, 0x40($sp)
-/* 38518 8005D118 D7B40038 */  ldc1      $f20, 0x38($sp)
-/* 3851C 8005D11C 03E00008 */  jr        $ra
-/* 38520 8005D120 27BD0068 */   addiu    $sp, $sp, 0x68
diff --git a/ver/us/asm/nonmatchings/362a0_len_2f70/test_ray_entities.s b/ver/us/asm/nonmatchings/362a0_len_2f70/test_ray_entities.s
deleted file mode 100644
index e3d5e0a38e..0000000000
--- a/ver/us/asm/nonmatchings/362a0_len_2f70/test_ray_entities.s
+++ /dev/null
@@ -1,454 +0,0 @@
-.set noat      # allow manual use of $at
-.set noreorder # don't insert nops after branches
-
-glabel test_ray_entities
-/* 38848 8005D448 27BDFE60 */  addiu     $sp, $sp, -0x1a0
-/* 3884C 8005D44C 44800000 */  mtc1      $zero, $f0
-/* 38850 8005D450 2409FFFF */  addiu     $t1, $zero, -1
-/* 38854 8005D454 AFA90140 */  sw        $t1, 0x140($sp)
-/* 38858 8005D458 8FA901C4 */  lw        $t1, 0x1c4($sp)
-/* 3885C 8005D45C AFA701AC */  sw        $a3, 0x1ac($sp)
-/* 38860 8005D460 C7A801AC */  lwc1      $f8, 0x1ac($sp)
-/* 38864 8005D464 F7BE0198 */  sdc1      $f30, 0x198($sp)
-/* 38868 8005D468 46006786 */  mov.s     $f30, $f12
-/* 3886C 8005D46C F7BA0188 */  sdc1      $f26, 0x188($sp)
-/* 38870 8005D470 46007686 */  mov.s     $f26, $f14
-/* 38874 8005D474 AFB60160 */  sw        $s6, 0x160($sp)
-/* 38878 8005D478 0000B02D */  daddu     $s6, $zero, $zero
-/* 3887C 8005D47C AFB20150 */  sw        $s2, 0x150($sp)
-/* 38880 8005D480 27B20100 */  addiu     $s2, $sp, 0x100
-/* 38884 8005D484 AFBF016C */  sw        $ra, 0x16c($sp)
-/* 38888 8005D488 AFBE0168 */  sw        $fp, 0x168($sp)
-/* 3888C 8005D48C AFB70164 */  sw        $s7, 0x164($sp)
-/* 38890 8005D490 AFB5015C */  sw        $s5, 0x15c($sp)
-/* 38894 8005D494 AFB40158 */  sw        $s4, 0x158($sp)
-/* 38898 8005D498 AFB30154 */  sw        $s3, 0x154($sp)
-/* 3889C 8005D49C AFB1014C */  sw        $s1, 0x14c($sp)
-/* 388A0 8005D4A0 AFB00148 */  sw        $s0, 0x148($sp)
-/* 388A4 8005D4A4 F7BC0190 */  sdc1      $f28, 0x190($sp)
-/* 388A8 8005D4A8 F7B80180 */  sdc1      $f24, 0x180($sp)
-/* 388AC 8005D4AC F7B60178 */  sdc1      $f22, 0x178($sp)
-/* 388B0 8005D4B0 F7B40170 */  sdc1      $f20, 0x170($sp)
-/* 388B4 8005D4B4 AFA601A8 */  sw        $a2, 0x1a8($sp)
-/* 388B8 8005D4B8 C5360000 */  lwc1      $f22, ($t1)
-/* 388BC 8005D4BC 46004032 */  c.eq.s    $f8, $f0
-/* 388C0 8005D4C0 00000000 */  nop
-/* 388C4 8005D4C4 4500000E */  bc1f      .L8005D500
-/* 388C8 8005D4C8 4600B606 */   mov.s    $f24, $f22
-/* 388CC 8005D4CC C7A801B4 */  lwc1      $f8, 0x1b4($sp)
-/* 388D0 8005D4D0 46004032 */  c.eq.s    $f8, $f0
-/* 388D4 8005D4D4 00000000 */  nop
-/* 388D8 8005D4D8 45000009 */  bc1f      .L8005D500
-/* 388DC 8005D4DC 00000000 */   nop
-/* 388E0 8005D4E0 C7A801B0 */  lwc1      $f8, 0x1b0($sp)
-/* 388E4 8005D4E4 4600403C */  c.lt.s    $f8, $f0
-/* 388E8 8005D4E8 00000000 */  nop
-/* 388EC 8005D4EC 45000005 */  bc1f      .L8005D504
-/* 388F0 8005D4F0 00000000 */   nop
-/* 388F4 8005D4F4 46000586 */  mov.s     $f22, $f0
-/* 388F8 8005D4F8 08017547 */  j         .L8005D51C
-/* 388FC 8005D4FC 24160001 */   addiu    $s6, $zero, 1
-.L8005D500:
-/* 38900 8005D500 C7A801B0 */  lwc1      $f8, 0x1b0($sp)
-.L8005D504:
-/* 38904 8005D504 46004032 */  c.eq.s    $f8, $f0
-/* 38908 8005D508 00000000 */  nop
-/* 3890C 8005D50C 45000004 */  bc1f      .L8005D520
-/* 38910 8005D510 0000F02D */   daddu    $fp, $zero, $zero
-/* 38914 8005D514 46000606 */  mov.s     $f24, $f0
-/* 38918 8005D518 24160002 */  addiu     $s6, $zero, 2
-.L8005D51C:
-/* 3891C 8005D51C 0000F02D */  daddu     $fp, $zero, $zero
-.L8005D520:
-/* 38920 8005D520 27B700A0 */  addiu     $s7, $sp, 0xa0
-/* 38924 8005D524 4480A000 */  mtc1      $zero, $f20
-/* 38928 8005D528 3C013F80 */  lui       $at, 0x3f80
-/* 3892C 8005D52C 4481E000 */  mtc1      $at, $f28
-/* 38930 8005D530 3C01BF80 */  lui       $at, 0xbf80
-/* 38934 8005D534 44810000 */  mtc1      $at, $f0
-/* 38938 8005D538 24020001 */  addiu     $v0, $zero, 1
-/* 3893C 8005D53C A642003C */  sh        $v0, 0x3c($s2)
-/* 38940 8005D540 3C01800A */  lui       $at, %hi(D_800A4254)
-/* 38944 8005D544 E4204254 */  swc1      $f0, %lo(D_800A4254)($at)
-.L8005D548:
-/* 38948 8005D548 0C04417A */  jal       get_entity_by_index
-/* 3894C 8005D54C 03C0202D */   daddu    $a0, $fp, $zero
-/* 38950 8005D550 0040882D */  daddu     $s1, $v0, $zero
-/* 38954 8005D554 52200154 */  beql      $s1, $zero, .L8005DAA8
-/* 38958 8005D558 27DE0001 */   addiu    $fp, $fp, 1
-/* 3895C 8005D55C 3C034000 */  lui       $v1, 0x4000
-/* 38960 8005D560 8E220000 */  lw        $v0, ($s1)
-/* 38964 8005D564 34630020 */  ori       $v1, $v1, 0x20
-/* 38968 8005D568 00431024 */  and       $v0, $v0, $v1
-/* 3896C 8005D56C 5440014E */  bnel      $v0, $zero, .L8005DAA8
-/* 38970 8005D570 27DE0001 */   addiu    $fp, $fp, 1
-/* 38974 8005D574 C62600B0 */  lwc1      $f6, 0xb0($s1)
-/* 38978 8005D578 4606B080 */  add.s     $f2, $f22, $f6
-/* 3897C 8005D57C C6240048 */  lwc1      $f4, 0x48($s1)
-/* 38980 8005D580 46022000 */  add.s     $f0, $f4, $f2
-/* 38984 8005D584 461E003C */  c.lt.s    $f0, $f30
-/* 38988 8005D588 00000000 */  nop
-/* 3898C 8005D58C 45030146 */  bc1tl     .L8005DAA8
-/* 38990 8005D590 27DE0001 */   addiu    $fp, $fp, 1
-/* 38994 8005D594 46022001 */  sub.s     $f0, $f4, $f2
-/* 38998 8005D598 4600F03C */  c.lt.s    $f30, $f0
-/* 3899C 8005D59C 00000000 */  nop
-/* 389A0 8005D5A0 45030141 */  bc1tl     .L8005DAA8
-/* 389A4 8005D5A4 27DE0001 */   addiu    $fp, $fp, 1
-/* 389A8 8005D5A8 C6240050 */  lwc1      $f4, 0x50($s1)
-/* 389AC 8005D5AC 46022000 */  add.s     $f0, $f4, $f2
-/* 389B0 8005D5B0 C7A801A8 */  lwc1      $f8, 0x1a8($sp)
-/* 389B4 8005D5B4 4608003C */  c.lt.s    $f0, $f8
-/* 389B8 8005D5B8 00000000 */  nop
-/* 389BC 8005D5BC 4503013A */  bc1tl     .L8005DAA8
-/* 389C0 8005D5C0 27DE0001 */   addiu    $fp, $fp, 1
-/* 389C4 8005D5C4 46022001 */  sub.s     $f0, $f4, $f2
-/* 389C8 8005D5C8 4600403C */  c.lt.s    $f8, $f0
-/* 389CC 8005D5CC 00000000 */  nop
-/* 389D0 8005D5D0 45030135 */  bc1tl     .L8005DAA8
-/* 389D4 8005D5D4 27DE0001 */   addiu    $fp, $fp, 1
-/* 389D8 8005D5D8 06C00016 */  bltz      $s6, .L8005D634
-/* 389DC 8005D5DC 2AC20002 */   slti     $v0, $s6, 2
-/* 389E0 8005D5E0 54400006 */  bnel      $v0, $zero, .L8005D5FC
-/* 389E4 8005D5E4 46063000 */   add.s    $f0, $f6, $f6
-/* 389E8 8005D5E8 24020002 */  addiu     $v0, $zero, 2
-/* 389EC 8005D5EC 12C20005 */  beq       $s6, $v0, .L8005D604
-/* 389F0 8005D5F0 26300070 */   addiu    $s0, $s1, 0x70
-/* 389F4 8005D5F4 0801758F */  j         .L8005D63C
-/* 389F8 8005D5F8 0200202D */   daddu    $a0, $s0, $zero
-.L8005D5FC:
-/* 389FC 8005D5FC 08017582 */  j         .L8005D608
-/* 38A00 8005D600 4600C100 */   add.s    $f4, $f24, $f0
-.L8005D604:
-/* 38A04 8005D604 46063100 */  add.s     $f4, $f6, $f6
-.L8005D608:
-/* 38A08 8005D608 C622004C */  lwc1      $f2, 0x4c($s1)
-/* 38A0C 8005D60C 46041000 */  add.s     $f0, $f2, $f4
-/* 38A10 8005D610 461A003C */  c.lt.s    $f0, $f26
-/* 38A14 8005D614 00000000 */  nop
-/* 38A18 8005D618 45030123 */  bc1tl     .L8005DAA8
-/* 38A1C 8005D61C 27DE0001 */   addiu    $fp, $fp, 1
-/* 38A20 8005D620 46041001 */  sub.s     $f0, $f2, $f4
-/* 38A24 8005D624 4600D03C */  c.lt.s    $f26, $f0
-/* 38A28 8005D628 00000000 */  nop
-/* 38A2C 8005D62C 4503011E */  bc1tl     .L8005DAA8
-/* 38A30 8005D630 27DE0001 */   addiu    $fp, $fp, 1
-.L8005D634:
-/* 38A34 8005D634 26300070 */  addiu     $s0, $s1, 0x70
-/* 38A38 8005D638 0200202D */  daddu     $a0, $s0, $zero
-.L8005D63C:
-/* 38A3C 8005D63C 0000A82D */  daddu     $s5, $zero, $zero
-/* 38A40 8005D640 3C148009 */  lui       $s4, %hi(D_8008FFB8)
-/* 38A44 8005D644 2694FFB8 */  addiu     $s4, $s4, %lo(D_8008FFB8)
-/* 38A48 8005D648 8FA501AC */  lw        $a1, 0x1ac($sp)
-/* 38A4C 8005D64C 8FA601B0 */  lw        $a2, 0x1b0($sp)
-/* 38A50 8005D650 8FA701B4 */  lw        $a3, 0x1b4($sp)
-/* 38A54 8005D654 9623000C */  lhu       $v1, 0xc($s1)
-/* 38A58 8005D658 96280010 */  lhu       $t0, 0x10($s1)
-/* 38A5C 8005D65C 3C138009 */  lui       $s3, %hi(D_8008FF70)
-/* 38A60 8005D660 2673FF70 */  addiu     $s3, $s3, %lo(D_8008FF70)
-/* 38A64 8005D664 E7B400C8 */  swc1      $f20, 0xc8($sp)
-/* 38A68 8005D668 E7B400BC */  swc1      $f20, 0xbc($sp)
-/* 38A6C 8005D66C E7B400B0 */  swc1      $f20, 0xb0($sp)
-/* 38A70 8005D670 E7B400A4 */  swc1      $f20, 0xa4($sp)
-/* 38A74 8005D674 00031C00 */  sll       $v1, $v1, 0x10
-/* 38A78 8005D678 00031403 */  sra       $v0, $v1, 0x10
-/* 38A7C 8005D67C 00031FC2 */  srl       $v1, $v1, 0x1f
-/* 38A80 8005D680 00431021 */  addu      $v0, $v0, $v1
-/* 38A84 8005D684 00021043 */  sra       $v0, $v0, 1
-/* 38A88 8005D688 44821000 */  mtc1      $v0, $f2
-/* 38A8C 8005D68C 00000000 */  nop
-/* 38A90 8005D690 468010A0 */  cvt.s.w   $f2, $f2
-/* 38A94 8005D694 00084400 */  sll       $t0, $t0, 0x10
-/* 38A98 8005D698 00081403 */  sra       $v0, $t0, 0x10
-/* 38A9C 8005D69C 000847C2 */  srl       $t0, $t0, 0x1f
-/* 38AA0 8005D6A0 00481021 */  addu      $v0, $v0, $t0
-/* 38AA4 8005D6A4 00021043 */  sra       $v0, $v0, 1
-/* 38AA8 8005D6A8 46001007 */  neg.s     $f0, $f2
-/* 38AAC 8005D6AC E7A000E8 */  swc1      $f0, 0xe8($sp)
-/* 38AB0 8005D6B0 E7A000DC */  swc1      $f0, 0xdc($sp)
-/* 38AB4 8005D6B4 E7A000B8 */  swc1      $f0, 0xb8($sp)
-/* 38AB8 8005D6B8 E7A000AC */  swc1      $f0, 0xac($sp)
-/* 38ABC 8005D6BC 44820000 */  mtc1      $v0, $f0
-/* 38AC0 8005D6C0 00000000 */  nop
-/* 38AC4 8005D6C4 46800020 */  cvt.s.w   $f0, $f0
-/* 38AC8 8005D6C8 E7A200F4 */  swc1      $f2, 0xf4($sp)
-/* 38ACC 8005D6CC E7A200D0 */  swc1      $f2, 0xd0($sp)
-/* 38AD0 8005D6D0 E7A200C4 */  swc1      $f2, 0xc4($sp)
-/* 38AD4 8005D6D4 E7A200A0 */  swc1      $f2, 0xa0($sp)
-/* 38AD8 8005D6D8 8623000E */  lh        $v1, 0xe($s1)
-/* 38ADC 8005D6DC 3C02800A */  lui       $v0, %hi(D_800A423C)
-/* 38AE0 8005D6E0 2442423C */  addiu     $v0, $v0, %lo(D_800A423C)
-/* 38AE4 8005D6E4 E7A000E4 */  swc1      $f0, 0xe4($sp)
-/* 38AE8 8005D6E8 E7A000D8 */  swc1      $f0, 0xd8($sp)
-/* 38AEC 8005D6EC E7A000B4 */  swc1      $f0, 0xb4($sp)
-/* 38AF0 8005D6F0 E7A000A8 */  swc1      $f0, 0xa8($sp)
-/* 38AF4 8005D6F4 46000007 */  neg.s     $f0, $f0
-/* 38AF8 8005D6F8 E7A000FC */  swc1      $f0, 0xfc($sp)
-/* 38AFC 8005D6FC E7A000F0 */  swc1      $f0, 0xf0($sp)
-/* 38B00 8005D700 E7A000CC */  swc1      $f0, 0xcc($sp)
-/* 38B04 8005D704 E7A000C0 */  swc1      $f0, 0xc0($sp)
-/* 38B08 8005D708 44830000 */  mtc1      $v1, $f0
-/* 38B0C 8005D70C 00000000 */  nop
-/* 38B10 8005D710 46800020 */  cvt.s.w   $f0, $f0
-/* 38B14 8005D714 E7A000F8 */  swc1      $f0, 0xf8($sp)
-/* 38B18 8005D718 E7A000EC */  swc1      $f0, 0xec($sp)
-/* 38B1C 8005D71C E7A000E0 */  swc1      $f0, 0xe0($sp)
-/* 38B20 8005D720 E7A000D4 */  swc1      $f0, 0xd4($sp)
-/* 38B24 8005D724 AFA20010 */  sw        $v0, 0x10($sp)
-/* 38B28 8005D728 3C02800A */  lui       $v0, %hi(D_800A4240)
-/* 38B2C 8005D72C 24424240 */  addiu     $v0, $v0, %lo(D_800A4240)
-/* 38B30 8005D730 AFA20014 */  sw        $v0, 0x14($sp)
-/* 38B34 8005D734 3C02800A */  lui       $v0, %hi(D_800A4244)
-/* 38B38 8005D738 24424244 */  addiu     $v0, $v0, %lo(D_800A4244)
-/* 38B3C 8005D73C 0C019E9C */  jal       guMtxXFMF
-/* 38B40 8005D740 AFA20018 */   sw       $v0, 0x18($sp)
-/* 38B44 8005D744 C6200048 */  lwc1      $f0, 0x48($s1)
-/* 38B48 8005D748 C6220050 */  lwc1      $f2, 0x50($s1)
-/* 38B4C 8005D74C 4600F001 */  sub.s     $f0, $f30, $f0
-/* 38B50 8005D750 C7A801A8 */  lwc1      $f8, 0x1a8($sp)
-/* 38B54 8005D754 0200202D */  daddu     $a0, $s0, $zero
-/* 38B58 8005D758 46024201 */  sub.s     $f8, $f8, $f2
-/* 38B5C 8005D75C 44050000 */  mfc1      $a1, $f0
-/* 38B60 8005D760 C620004C */  lwc1      $f0, 0x4c($s1)
-/* 38B64 8005D764 44074000 */  mfc1      $a3, $f8
-/* 38B68 8005D768 3C02800A */  lui       $v0, %hi(D_800A4230)
-/* 38B6C 8005D76C 24424230 */  addiu     $v0, $v0, %lo(D_800A4230)
-/* 38B70 8005D770 AFA20010 */  sw        $v0, 0x10($sp)
-/* 38B74 8005D774 4600D001 */  sub.s     $f0, $f26, $f0
-/* 38B78 8005D778 3C02800A */  lui       $v0, %hi(D_800A4234)
-/* 38B7C 8005D77C 24424234 */  addiu     $v0, $v0, %lo(D_800A4234)
-/* 38B80 8005D780 AFA20014 */  sw        $v0, 0x14($sp)
-/* 38B84 8005D784 44060000 */  mfc1      $a2, $f0
-/* 38B88 8005D788 3C02800A */  lui       $v0, %hi(D_800A4238)
-/* 38B8C 8005D78C 24424238 */  addiu     $v0, $v0, %lo(D_800A4238)
-/* 38B90 8005D790 0C019E9C */  jal       guMtxXFMF
-/* 38B94 8005D794 AFA20018 */   sw       $v0, 0x18($sp)
-.L8005D798:
-/* 38B98 8005D798 86620000 */  lh        $v0, ($s3)
-/* 38B9C 8005D79C 00021840 */  sll       $v1, $v0, 1
-/* 38BA0 8005D7A0 00621821 */  addu      $v1, $v1, $v0
-/* 38BA4 8005D7A4 00031880 */  sll       $v1, $v1, 2
-/* 38BA8 8005D7A8 02E31821 */  addu      $v1, $s7, $v1
-/* 38BAC 8005D7AC AE430000 */  sw        $v1, ($s2)
-/* 38BB0 8005D7B0 86620002 */  lh        $v0, 2($s3)
-/* 38BB4 8005D7B4 00022840 */  sll       $a1, $v0, 1
-/* 38BB8 8005D7B8 00A22821 */  addu      $a1, $a1, $v0
-/* 38BBC 8005D7BC 00052880 */  sll       $a1, $a1, 2
-/* 38BC0 8005D7C0 02E52821 */  addu      $a1, $s7, $a1
-/* 38BC4 8005D7C4 AE450004 */  sw        $a1, 4($s2)
-/* 38BC8 8005D7C8 86620004 */  lh        $v0, 4($s3)
-/* 38BCC 8005D7CC 00022040 */  sll       $a0, $v0, 1
-/* 38BD0 8005D7D0 00822021 */  addu      $a0, $a0, $v0
-/* 38BD4 8005D7D4 00042080 */  sll       $a0, $a0, 2
-/* 38BD8 8005D7D8 02E42021 */  addu      $a0, $s7, $a0
-/* 38BDC 8005D7DC AE440008 */  sw        $a0, 8($s2)
-/* 38BE0 8005D7E0 C4800000 */  lwc1      $f0, ($a0)
-/* 38BE4 8005D7E4 C4620000 */  lwc1      $f2, ($v1)
-/* 38BE8 8005D7E8 46020001 */  sub.s     $f0, $f0, $f2
-/* 38BEC 8005D7EC E640000C */  swc1      $f0, 0xc($s2)
-/* 38BF0 8005D7F0 C4800004 */  lwc1      $f0, 4($a0)
-/* 38BF4 8005D7F4 C4620004 */  lwc1      $f2, 4($v1)
-/* 38BF8 8005D7F8 46020001 */  sub.s     $f0, $f0, $f2
-/* 38BFC 8005D7FC E6400010 */  swc1      $f0, 0x10($s2)
-/* 38C00 8005D800 C4800008 */  lwc1      $f0, 8($a0)
-/* 38C04 8005D804 C4620008 */  lwc1      $f2, 8($v1)
-/* 38C08 8005D808 46020001 */  sub.s     $f0, $f0, $f2
-/* 38C0C 8005D80C E6400014 */  swc1      $f0, 0x14($s2)
-/* 38C10 8005D810 C4600000 */  lwc1      $f0, ($v1)
-/* 38C14 8005D814 C4A20000 */  lwc1      $f2, ($a1)
-/* 38C18 8005D818 46020001 */  sub.s     $f0, $f0, $f2
-/* 38C1C 8005D81C E6400018 */  swc1      $f0, 0x18($s2)
-/* 38C20 8005D820 C4600004 */  lwc1      $f0, 4($v1)
-/* 38C24 8005D824 C4A20004 */  lwc1      $f2, 4($a1)
-/* 38C28 8005D828 46020001 */  sub.s     $f0, $f0, $f2
-/* 38C2C 8005D82C E640001C */  swc1      $f0, 0x1c($s2)
-/* 38C30 8005D830 C4600008 */  lwc1      $f0, 8($v1)
-/* 38C34 8005D834 C4A20008 */  lwc1      $f2, 8($a1)
-/* 38C38 8005D838 46020001 */  sub.s     $f0, $f0, $f2
-/* 38C3C 8005D83C E6400020 */  swc1      $f0, 0x20($s2)
-/* 38C40 8005D840 C4A00000 */  lwc1      $f0, ($a1)
-/* 38C44 8005D844 C4820000 */  lwc1      $f2, ($a0)
-/* 38C48 8005D848 46020001 */  sub.s     $f0, $f0, $f2
-/* 38C4C 8005D84C E6400024 */  swc1      $f0, 0x24($s2)
-/* 38C50 8005D850 C4A00004 */  lwc1      $f0, 4($a1)
-/* 38C54 8005D854 C4820004 */  lwc1      $f2, 4($a0)
-/* 38C58 8005D858 46020001 */  sub.s     $f0, $f0, $f2
-/* 38C5C 8005D85C E6400028 */  swc1      $f0, 0x28($s2)
-/* 38C60 8005D860 C4A00008 */  lwc1      $f0, 8($a1)
-/* 38C64 8005D864 C4820008 */  lwc1      $f2, 8($a0)
-/* 38C68 8005D868 46020001 */  sub.s     $f0, $f0, $f2
-/* 38C6C 8005D86C E640002C */  swc1      $f0, 0x2c($s2)
-/* 38C70 8005D870 C6800000 */  lwc1      $f0, ($s4)
-/* 38C74 8005D874 E6400030 */  swc1      $f0, 0x30($s2)
-/* 38C78 8005D878 C6800004 */  lwc1      $f0, 4($s4)
-/* 38C7C 8005D87C 27A40100 */  addiu     $a0, $sp, 0x100
-/* 38C80 8005D880 E6400034 */  swc1      $f0, 0x34($s2)
-/* 38C84 8005D884 C6800008 */  lwc1      $f0, 8($s4)
-/* 38C88 8005D888 02E0282D */  daddu     $a1, $s7, $zero
-/* 38C8C 8005D88C 0C016FA1 */  jal       test_ray_triangle_general
-/* 38C90 8005D890 E6400038 */   swc1     $f0, 0x38($s2)
-/* 38C94 8005D894 0040182D */  daddu     $v1, $v0, $zero
-/* 38C98 8005D898 14600008 */  bnez      $v1, .L8005D8BC
-/* 38C9C 8005D89C 00000000 */   nop
-/* 38CA0 8005D8A0 2694000C */  addiu     $s4, $s4, 0xc
-/* 38CA4 8005D8A4 26B50001 */  addiu     $s5, $s5, 1
-/* 38CA8 8005D8A8 2AA2000C */  slti      $v0, $s5, 0xc
-/* 38CAC 8005D8AC 1440FFBA */  bnez      $v0, .L8005D798
-/* 38CB0 8005D8B0 26730006 */   addiu    $s3, $s3, 6
-/* 38CB4 8005D8B4 5060007C */  beql      $v1, $zero, .L8005DAA8
-/* 38CB8 8005D8B8 27DE0001 */   addiu    $fp, $fp, 1
-.L8005D8BC:
-/* 38CBC 8005D8BC 3C03800A */  lui       $v1, %hi(D_800A4254)
-/* 38CC0 8005D8C0 24634254 */  addiu     $v1, $v1, %lo(D_800A4254)
-/* 38CC4 8005D8C4 8FA901C4 */  lw        $t1, 0x1c4($sp)
-/* 38CC8 8005D8C8 C4620000 */  lwc1      $f2, ($v1)
-/* 38CCC 8005D8CC C5200000 */  lwc1      $f0, ($t1)
-/* 38CD0 8005D8D0 4600103C */  c.lt.s    $f2, $f0
-/* 38CD4 8005D8D4 00000000 */  nop
-/* 38CD8 8005D8D8 45020073 */  bc1fl     .L8005DAA8
-/* 38CDC 8005D8DC 27DE0001 */   addiu    $fp, $fp, 1
-/* 38CE0 8005D8E0 24020001 */  addiu     $v0, $zero, 1
-/* 38CE4 8005D8E4 AFBE0140 */  sw        $fp, 0x140($sp)
-/* 38CE8 8005D8E8 12C2000F */  beq       $s6, $v0, .L8005D928
-/* 38CEC 8005D8EC E5220000 */   swc1     $f2, ($t1)
-/* 38CF0 8005D8F0 2AC20002 */  slti      $v0, $s6, 2
-/* 38CF4 8005D8F4 10400005 */  beqz      $v0, .L8005D90C
-/* 38CF8 8005D8F8 24020002 */   addiu    $v0, $zero, 2
-/* 38CFC 8005D8FC 12C00007 */  beqz      $s6, .L8005D91C
-/* 38D00 8005D900 00000000 */   nop
-/* 38D04 8005D904 0801764F */  j         .L8005D93C
-/* 38D08 8005D908 E7B40010 */   swc1     $f20, 0x10($sp)
-.L8005D90C:
-/* 38D0C 8005D90C 12C20009 */  beq       $s6, $v0, .L8005D934
-/* 38D10 8005D910 00000000 */   nop
-/* 38D14 8005D914 0801764F */  j         .L8005D93C
-/* 38D18 8005D918 E7B40010 */   swc1     $f20, 0x10($sp)
-.L8005D91C:
-/* 38D1C 8005D91C C4760000 */  lwc1      $f22, ($v1)
-/* 38D20 8005D920 0801764E */  j         .L8005D938
-/* 38D24 8005D924 4600B606 */   mov.s    $f24, $f22
-.L8005D928:
-/* 38D28 8005D928 C4780000 */  lwc1      $f24, ($v1)
-/* 38D2C 8005D92C 0801764F */  j         .L8005D93C
-/* 38D30 8005D930 E7B40010 */   swc1     $f20, 0x10($sp)
-.L8005D934:
-/* 38D34 8005D934 C4760000 */  lwc1      $f22, ($v1)
-.L8005D938:
-/* 38D38 8005D938 E7B40010 */  swc1      $f20, 0x10($sp)
-.L8005D93C:
-/* 38D3C 8005D93C 8E250060 */  lw        $a1, 0x60($s1)
-/* 38D40 8005D940 4406E000 */  mfc1      $a2, $f28
-/* 38D44 8005D944 4407A000 */  mfc1      $a3, $f20
-/* 38D48 8005D948 0C019EC8 */  jal       guRotateF
-/* 38D4C 8005D94C 27A40020 */   addiu    $a0, $sp, 0x20
-/* 38D50 8005D950 27B00060 */  addiu     $s0, $sp, 0x60
-/* 38D54 8005D954 E7BC0010 */  swc1      $f28, 0x10($sp)
-/* 38D58 8005D958 8E250068 */  lw        $a1, 0x68($s1)
-/* 38D5C 8005D95C 4406A000 */  mfc1      $a2, $f20
-/* 38D60 8005D960 4407A000 */  mfc1      $a3, $f20
-/* 38D64 8005D964 0C019EC8 */  jal       guRotateF
-/* 38D68 8005D968 0200202D */   daddu    $a0, $s0, $zero
-/* 38D6C 8005D96C 27A40020 */  addiu     $a0, $sp, 0x20
-/* 38D70 8005D970 0200282D */  daddu     $a1, $s0, $zero
-/* 38D74 8005D974 0C019D80 */  jal       guMtxCatF
-/* 38D78 8005D978 0080302D */   daddu    $a2, $a0, $zero
-/* 38D7C 8005D97C E7B40010 */  swc1      $f20, 0x10($sp)
-/* 38D80 8005D980 8E250064 */  lw        $a1, 0x64($s1)
-/* 38D84 8005D984 4406A000 */  mfc1      $a2, $f20
-/* 38D88 8005D988 4407E000 */  mfc1      $a3, $f28
-/* 38D8C 8005D98C 0C019EC8 */  jal       guRotateF
-/* 38D90 8005D990 0200202D */   daddu    $a0, $s0, $zero
-/* 38D94 8005D994 27A40020 */  addiu     $a0, $sp, 0x20
-/* 38D98 8005D998 0200282D */  daddu     $a1, $s0, $zero
-/* 38D9C 8005D99C 0C019D80 */  jal       guMtxCatF
-/* 38DA0 8005D9A0 0080302D */   daddu    $a2, $a0, $zero
-/* 38DA4 8005D9A4 8E250048 */  lw        $a1, 0x48($s1)
-/* 38DA8 8005D9A8 8E26004C */  lw        $a2, 0x4c($s1)
-/* 38DAC 8005D9AC 8E270050 */  lw        $a3, 0x50($s1)
-/* 38DB0 8005D9B0 0C019E40 */  jal       guTranslateF
-/* 38DB4 8005D9B4 0200202D */   daddu    $a0, $s0, $zero
-/* 38DB8 8005D9B8 27A40020 */  addiu     $a0, $sp, 0x20
-/* 38DBC 8005D9BC 0200282D */  daddu     $a1, $s0, $zero
-/* 38DC0 8005D9C0 0C019D80 */  jal       guMtxCatF
-/* 38DC4 8005D9C4 0080302D */   daddu    $a2, $a0, $zero
-/* 38DC8 8005D9C8 8FA901B8 */  lw        $t1, 0x1b8($sp)
-/* 38DCC 8005D9CC 3C05800A */  lui       $a1, %hi(D_800A4248)
-/* 38DD0 8005D9D0 8CA54248 */  lw        $a1, %lo(D_800A4248)($a1)
-/* 38DD4 8005D9D4 3C06800A */  lui       $a2, %hi(D_800A424C)
-/* 38DD8 8005D9D8 8CC6424C */  lw        $a2, %lo(D_800A424C)($a2)
-/* 38DDC 8005D9DC 3C07800A */  lui       $a3, %hi(D_800A4250)
-/* 38DE0 8005D9E0 8CE74250 */  lw        $a3, %lo(D_800A4250)($a3)
-/* 38DE4 8005D9E4 AFA90010 */  sw        $t1, 0x10($sp)
-/* 38DE8 8005D9E8 8FA901BC */  lw        $t1, 0x1bc($sp)
-/* 38DEC 8005D9EC AFA90014 */  sw        $t1, 0x14($sp)
-/* 38DF0 8005D9F0 8FA901C0 */  lw        $t1, 0x1c0($sp)
-/* 38DF4 8005D9F4 27A40020 */  addiu     $a0, $sp, 0x20
-/* 38DF8 8005D9F8 0C019E9C */  jal       guMtxXFMF
-/* 38DFC 8005D9FC AFA90018 */   sw       $t1, 0x18($sp)
-/* 38E00 8005DA00 3C10800A */  lui       $s0, %hi(D_800A4258)
-/* 38E04 8005DA04 26104258 */  addiu     $s0, $s0, %lo(D_800A4258)
-/* 38E08 8005DA08 C6040000 */  lwc1      $f4, ($s0)
-/* 38E0C 8005DA0C 46042102 */  mul.s     $f4, $f4, $f4
-/* 38E10 8005DA10 00000000 */  nop
-/* 38E14 8005DA14 3C11800A */  lui       $s1, %hi(D_800A425C)
-/* 38E18 8005DA18 2631425C */  addiu     $s1, $s1, %lo(D_800A425C)
-/* 38E1C 8005DA1C C6220000 */  lwc1      $f2, ($s1)
-/* 38E20 8005DA20 46021082 */  mul.s     $f2, $f2, $f2
-/* 38E24 8005DA24 00000000 */  nop
-/* 38E28 8005DA28 3C13800A */  lui       $s3, %hi(D_800A4260)
-/* 38E2C 8005DA2C 26734260 */  addiu     $s3, $s3, %lo(D_800A4260)
-/* 38E30 8005DA30 C6600000 */  lwc1      $f0, ($s3)
-/* 38E34 8005DA34 46000002 */  mul.s     $f0, $f0, $f0
-/* 38E38 8005DA38 00000000 */  nop
-/* 38E3C 8005DA3C 46022100 */  add.s     $f4, $f4, $f2
-/* 38E40 8005DA40 46002300 */  add.s     $f12, $f4, $f0
-/* 38E44 8005DA44 46006084 */  sqrt.s    $f2, $f12
-/* 38E48 8005DA48 46021032 */  c.eq.s    $f2, $f2
-/* 38E4C 8005DA4C 00000000 */  nop
-/* 38E50 8005DA50 45010004 */  bc1t      .L8005DA64
-/* 38E54 8005DA54 00000000 */   nop
-/* 38E58 8005DA58 0C0187BC */  jal       sqrtf
-/* 38E5C 8005DA5C 00000000 */   nop
-/* 38E60 8005DA60 46000086 */  mov.s     $f2, $f0
-.L8005DA64:
-/* 38E64 8005DA64 C6000000 */  lwc1      $f0, ($s0)
-/* 38E68 8005DA68 4602E083 */  div.s     $f2, $f28, $f2
-/* 38E6C 8005DA6C 46020002 */  mul.s     $f0, $f0, $f2
-/* 38E70 8005DA70 00000000 */  nop
-/* 38E74 8005DA74 8FA901C8 */  lw        $t1, 0x1c8($sp)
-/* 38E78 8005DA78 E5200000 */  swc1      $f0, ($t1)
-/* 38E7C 8005DA7C C6200000 */  lwc1      $f0, ($s1)
-/* 38E80 8005DA80 46020002 */  mul.s     $f0, $f0, $f2
-/* 38E84 8005DA84 00000000 */  nop
-/* 38E88 8005DA88 8FA901CC */  lw        $t1, 0x1cc($sp)
-/* 38E8C 8005DA8C E5200000 */  swc1      $f0, ($t1)
-/* 38E90 8005DA90 C6600000 */  lwc1      $f0, ($s3)
-/* 38E94 8005DA94 46020002 */  mul.s     $f0, $f0, $f2
-/* 38E98 8005DA98 00000000 */  nop
-/* 38E9C 8005DA9C 8FA901D0 */  lw        $t1, 0x1d0($sp)
-/* 38EA0 8005DAA0 E5200000 */  swc1      $f0, ($t1)
-/* 38EA4 8005DAA4 27DE0001 */  addiu     $fp, $fp, 1
-.L8005DAA8:
-/* 38EA8 8005DAA8 2BC2001E */  slti      $v0, $fp, 0x1e
-/* 38EAC 8005DAAC 1440FEA6 */  bnez      $v0, .L8005D548
-/* 38EB0 8005DAB0 00000000 */   nop
-/* 38EB4 8005DAB4 8FA20140 */  lw        $v0, 0x140($sp)
-/* 38EB8 8005DAB8 8FBF016C */  lw        $ra, 0x16c($sp)
-/* 38EBC 8005DABC 8FBE0168 */  lw        $fp, 0x168($sp)
-/* 38EC0 8005DAC0 8FB70164 */  lw        $s7, 0x164($sp)
-/* 38EC4 8005DAC4 8FB60160 */  lw        $s6, 0x160($sp)
-/* 38EC8 8005DAC8 8FB5015C */  lw        $s5, 0x15c($sp)
-/* 38ECC 8005DACC 8FB40158 */  lw        $s4, 0x158($sp)
-/* 38ED0 8005DAD0 8FB30154 */  lw        $s3, 0x154($sp)
-/* 38ED4 8005DAD4 8FB20150 */  lw        $s2, 0x150($sp)
-/* 38ED8 8005DAD8 8FB1014C */  lw        $s1, 0x14c($sp)
-/* 38EDC 8005DADC 8FB00148 */  lw        $s0, 0x148($sp)
-/* 38EE0 8005DAE0 D7BE0198 */  ldc1      $f30, 0x198($sp)
-/* 38EE4 8005DAE4 D7BC0190 */  ldc1      $f28, 0x190($sp)
-/* 38EE8 8005DAE8 D7BA0188 */  ldc1      $f26, 0x188($sp)
-/* 38EEC 8005DAEC D7B80180 */  ldc1      $f24, 0x180($sp)
-/* 38EF0 8005DAF0 D7B60178 */  ldc1      $f22, 0x178($sp)
-/* 38EF4 8005DAF4 D7B40170 */  ldc1      $f20, 0x170($sp)
-/* 38EF8 8005DAF8 03E00008 */  jr        $ra
-/* 38EFC 8005DAFC 27BD01A0 */   addiu    $sp, $sp, 0x1a0
diff --git a/ver/us/asm/nonmatchings/362a0_len_2f70/test_ray_triangle_general.s b/ver/us/asm/nonmatchings/362a0_len_2f70/test_ray_triangle_general.s
deleted file mode 100644
index 5f6dd05ddc..0000000000
--- a/ver/us/asm/nonmatchings/362a0_len_2f70/test_ray_triangle_general.s
+++ /dev/null
@@ -1,399 +0,0 @@
-.set noat      # allow manual use of $at
-.set noreorder # don't insert nops after branches
-
-glabel test_ray_triangle_general
-/* 37284 8005BE84 27BDFFC0 */  addiu     $sp, $sp, -0x40
-/* 37288 8005BE88 F7BE0038 */  sdc1      $f30, 0x38($sp)
-/* 3728C 8005BE8C F7BC0030 */  sdc1      $f28, 0x30($sp)
-/* 37290 8005BE90 F7BA0028 */  sdc1      $f26, 0x28($sp)
-/* 37294 8005BE94 F7B80020 */  sdc1      $f24, 0x20($sp)
-/* 37298 8005BE98 F7B60018 */  sdc1      $f22, 0x18($sp)
-/* 3729C 8005BE9C F7B40010 */  sdc1      $f20, 0x10($sp)
-/* 372A0 8005BEA0 C4800030 */  lwc1      $f0, 0x30($a0)
-/* 372A4 8005BEA4 44801000 */  mtc1      $zero, $f2
-/* 372A8 8005BEA8 00000000 */  nop
-/* 372AC 8005BEAC 46020032 */  c.eq.s    $f0, $f2
-/* 372B0 8005BEB0 00000000 */  nop
-/* 372B4 8005BEB4 4500000B */  bc1f      .L8005BEE4
-/* 372B8 8005BEB8 00000000 */   nop
-/* 372BC 8005BEBC C4800034 */  lwc1      $f0, 0x34($a0)
-/* 372C0 8005BEC0 46020032 */  c.eq.s    $f0, $f2
-/* 372C4 8005BEC4 00000000 */  nop
-/* 372C8 8005BEC8 45000006 */  bc1f      .L8005BEE4
-/* 372CC 8005BECC 00000000 */   nop
-/* 372D0 8005BED0 C4800038 */  lwc1      $f0, 0x38($a0)
-/* 372D4 8005BED4 46020032 */  c.eq.s    $f0, $f2
-/* 372D8 8005BED8 00000000 */  nop
-/* 372DC 8005BEDC 45010167 */  bc1t      .L8005C47C
-/* 372E0 8005BEE0 0000102D */   daddu    $v0, $zero, $zero
-.L8005BEE4:
-/* 372E4 8005BEE4 8C820000 */  lw        $v0, ($a0)
-/* 372E8 8005BEE8 3C01800A */  lui       $at, %hi(D_800A4230)
-/* 372EC 8005BEEC C43A4230 */  lwc1      $f26, %lo(D_800A4230)($at)
-/* 372F0 8005BEF0 C4400000 */  lwc1      $f0, ($v0)
-/* 372F4 8005BEF4 4600D001 */  sub.s     $f0, $f26, $f0
-/* 372F8 8005BEF8 E7A00008 */  swc1      $f0, 8($sp)
-/* 372FC 8005BEFC C48A0030 */  lwc1      $f10, 0x30($a0)
-/* 37300 8005BF00 46005082 */  mul.s     $f2, $f10, $f0
-/* 37304 8005BF04 00000000 */  nop
-/* 37308 8005BF08 3C01800A */  lui       $at, %hi(D_800A4234)
-/* 3730C 8005BF0C C43C4234 */  lwc1      $f28, %lo(D_800A4234)($at)
-/* 37310 8005BF10 C4400004 */  lwc1      $f0, 4($v0)
-/* 37314 8005BF14 4600E601 */  sub.s     $f24, $f28, $f0
-/* 37318 8005BF18 C4880034 */  lwc1      $f8, 0x34($a0)
-/* 3731C 8005BF1C 3C01800A */  lui       $at, %hi(D_800A4238)
-/* 37320 8005BF20 C4324238 */  lwc1      $f18, %lo(D_800A4238)($at)
-/* 37324 8005BF24 46184102 */  mul.s     $f4, $f8, $f24
-/* 37328 8005BF28 00000000 */  nop
-/* 3732C 8005BF2C E7B20000 */  swc1      $f18, ($sp)
-/* 37330 8005BF30 C4400008 */  lwc1      $f0, 8($v0)
-/* 37334 8005BF34 46009581 */  sub.s     $f22, $f18, $f0
-/* 37338 8005BF38 C4860038 */  lwc1      $f6, 0x38($a0)
-/* 3733C 8005BF3C 46163002 */  mul.s     $f0, $f6, $f22
-/* 37340 8005BF40 00000000 */  nop
-/* 37344 8005BF44 8C830004 */  lw        $v1, 4($a0)
-/* 37348 8005BF48 46041080 */  add.s     $f2, $f2, $f4
-/* 3734C 8005BF4C 8C850008 */  lw        $a1, 8($a0)
-/* 37350 8005BF50 8482003C */  lh        $v0, 0x3c($a0)
-/* 37354 8005BF54 1040007E */  beqz      $v0, .L8005C150
-/* 37358 8005BF58 46001500 */   add.s    $f20, $f2, $f0
-/* 3735C 8005BF5C 4480F000 */  mtc1      $zero, $f30
-/* 37360 8005BF60 00000000 */  nop
-/* 37364 8005BF64 461EA03C */  c.lt.s    $f20, $f30
-/* 37368 8005BF68 00000000 */  nop
-/* 3736C 8005BF6C 45030143 */  bc1tl     .L8005C47C
-/* 37370 8005BF70 0000102D */   daddu    $v0, $zero, $zero
-/* 37374 8005BF74 3C01800A */  lui       $at, %hi(D_800A423C)
-/* 37378 8005BF78 C430423C */  lwc1      $f16, %lo(D_800A423C)($at)
-/* 3737C 8005BF7C 46105002 */  mul.s     $f0, $f10, $f16
-/* 37380 8005BF80 00000000 */  nop
-/* 37384 8005BF84 3C01800A */  lui       $at, %hi(D_800A4240)
-/* 37388 8005BF88 C42E4240 */  lwc1      $f14, %lo(D_800A4240)($at)
-/* 3738C 8005BF8C 460E4102 */  mul.s     $f4, $f8, $f14
-/* 37390 8005BF90 00000000 */  nop
-/* 37394 8005BF94 3C01800A */  lui       $at, %hi(D_800A4244)
-/* 37398 8005BF98 C42C4244 */  lwc1      $f12, %lo(D_800A4244)($at)
-/* 3739C 8005BF9C 460C3082 */  mul.s     $f2, $f6, $f12
-/* 373A0 8005BFA0 00000000 */  nop
-/* 373A4 8005BFA4 46040000 */  add.s     $f0, $f0, $f4
-/* 373A8 8005BFA8 46020000 */  add.s     $f0, $f0, $f2
-/* 373AC 8005BFAC 4600F03E */  c.le.s    $f30, $f0
-/* 373B0 8005BFB0 00000000 */  nop
-/* 373B4 8005BFB4 45010131 */  bc1t      .L8005C47C
-/* 373B8 8005BFB8 0000102D */   daddu    $v0, $zero, $zero
-/* 373BC 8005BFBC C4880014 */  lwc1      $f8, 0x14($a0)
-/* 373C0 8005BFC0 460E4102 */  mul.s     $f4, $f8, $f14
-/* 373C4 8005BFC4 00000000 */  nop
-/* 373C8 8005BFC8 C4820010 */  lwc1      $f2, 0x10($a0)
-/* 373CC 8005BFCC 460C1002 */  mul.s     $f0, $f2, $f12
-/* 373D0 8005BFD0 00000000 */  nop
-/* 373D4 8005BFD4 46104202 */  mul.s     $f8, $f8, $f16
-/* 373D8 8005BFD8 00000000 */  nop
-/* 373DC 8005BFDC 46101082 */  mul.s     $f2, $f2, $f16
-/* 373E0 8005BFE0 00000000 */  nop
-/* 373E4 8005BFE4 46002101 */  sub.s     $f4, $f4, $f0
-/* 373E8 8005BFE8 C486000C */  lwc1      $f6, 0xc($a0)
-/* 373EC 8005BFEC 460C3002 */  mul.s     $f0, $f6, $f12
-/* 373F0 8005BFF0 00000000 */  nop
-/* 373F4 8005BFF4 460E3182 */  mul.s     $f6, $f6, $f14
-/* 373F8 8005BFF8 00000000 */  nop
-/* 373FC 8005BFFC C7B20008 */  lwc1      $f18, 8($sp)
-/* 37400 8005C000 46049102 */  mul.s     $f4, $f18, $f4
-/* 37404 8005C004 00000000 */  nop
-/* 37408 8005C008 46080001 */  sub.s     $f0, $f0, $f8
-/* 3740C 8005C00C 4600C002 */  mul.s     $f0, $f24, $f0
-/* 37410 8005C010 00000000 */  nop
-/* 37414 8005C014 46061081 */  sub.s     $f2, $f2, $f6
-/* 37418 8005C018 4602B082 */  mul.s     $f2, $f22, $f2
-/* 3741C 8005C01C 00000000 */  nop
-/* 37420 8005C020 46002100 */  add.s     $f4, $f4, $f0
-/* 37424 8005C024 46022100 */  add.s     $f4, $f4, $f2
-/* 37428 8005C028 461E203C */  c.lt.s    $f4, $f30
-/* 3742C 8005C02C 00000000 */  nop
-/* 37430 8005C030 45010112 */  bc1t      .L8005C47C
-/* 37434 8005C034 00000000 */   nop
-/* 37438 8005C038 C48A0020 */  lwc1      $f10, 0x20($a0)
-/* 3743C 8005C03C 460E5002 */  mul.s     $f0, $f10, $f14
-/* 37440 8005C040 00000000 */  nop
-/* 37444 8005C044 C488001C */  lwc1      $f8, 0x1c($a0)
-/* 37448 8005C048 460C4102 */  mul.s     $f4, $f8, $f12
-/* 3744C 8005C04C 00000000 */  nop
-/* 37450 8005C050 46105282 */  mul.s     $f10, $f10, $f16
-/* 37454 8005C054 00000000 */  nop
-/* 37458 8005C058 46104202 */  mul.s     $f8, $f8, $f16
-/* 3745C 8005C05C 00000000 */  nop
-/* 37460 8005C060 C4620000 */  lwc1      $f2, ($v1)
-/* 37464 8005C064 4602D081 */  sub.s     $f2, $f26, $f2
-/* 37468 8005C068 46040001 */  sub.s     $f0, $f0, $f4
-/* 3746C 8005C06C 46001082 */  mul.s     $f2, $f2, $f0
-/* 37470 8005C070 00000000 */  nop
-/* 37474 8005C074 C4860018 */  lwc1      $f6, 0x18($a0)
-/* 37478 8005C078 460C3002 */  mul.s     $f0, $f6, $f12
-/* 3747C 8005C07C 00000000 */  nop
-/* 37480 8005C080 460E3182 */  mul.s     $f6, $f6, $f14
-/* 37484 8005C084 00000000 */  nop
-/* 37488 8005C088 C4640004 */  lwc1      $f4, 4($v1)
-/* 3748C 8005C08C 4604E101 */  sub.s     $f4, $f28, $f4
-/* 37490 8005C090 460A0001 */  sub.s     $f0, $f0, $f10
-/* 37494 8005C094 46002102 */  mul.s     $f4, $f4, $f0
-/* 37498 8005C098 00000000 */  nop
-/* 3749C 8005C09C C7B20000 */  lwc1      $f18, ($sp)
-/* 374A0 8005C0A0 46064201 */  sub.s     $f8, $f8, $f6
-/* 374A4 8005C0A4 C4600008 */  lwc1      $f0, 8($v1)
-/* 374A8 8005C0A8 46009001 */  sub.s     $f0, $f18, $f0
-/* 374AC 8005C0AC 46080002 */  mul.s     $f0, $f0, $f8
-/* 374B0 8005C0B0 00000000 */  nop
-/* 374B4 8005C0B4 46041080 */  add.s     $f2, $f2, $f4
-/* 374B8 8005C0B8 46001080 */  add.s     $f2, $f2, $f0
-/* 374BC 8005C0BC 461E103C */  c.lt.s    $f2, $f30
-/* 374C0 8005C0C0 00000000 */  nop
-/* 374C4 8005C0C4 450100ED */  bc1t      .L8005C47C
-/* 374C8 8005C0C8 00000000 */   nop
-/* 374CC 8005C0CC C48A002C */  lwc1      $f10, 0x2c($a0)
-/* 374D0 8005C0D0 460E5002 */  mul.s     $f0, $f10, $f14
-/* 374D4 8005C0D4 00000000 */  nop
-/* 374D8 8005C0D8 C4880028 */  lwc1      $f8, 0x28($a0)
-/* 374DC 8005C0DC 460C4102 */  mul.s     $f4, $f8, $f12
-/* 374E0 8005C0E0 00000000 */  nop
-/* 374E4 8005C0E4 46105282 */  mul.s     $f10, $f10, $f16
-/* 374E8 8005C0E8 00000000 */  nop
-/* 374EC 8005C0EC 46104202 */  mul.s     $f8, $f8, $f16
-/* 374F0 8005C0F0 00000000 */  nop
-/* 374F4 8005C0F4 C4A20000 */  lwc1      $f2, ($a1)
-/* 374F8 8005C0F8 4602D081 */  sub.s     $f2, $f26, $f2
-/* 374FC 8005C0FC 46040001 */  sub.s     $f0, $f0, $f4
-/* 37500 8005C100 46001082 */  mul.s     $f2, $f2, $f0
-/* 37504 8005C104 00000000 */  nop
-/* 37508 8005C108 C4860024 */  lwc1      $f6, 0x24($a0)
-/* 3750C 8005C10C 460C3002 */  mul.s     $f0, $f6, $f12
-/* 37510 8005C110 00000000 */  nop
-/* 37514 8005C114 460E3182 */  mul.s     $f6, $f6, $f14
-/* 37518 8005C118 00000000 */  nop
-/* 3751C 8005C11C C4A40004 */  lwc1      $f4, 4($a1)
-/* 37520 8005C120 4604E101 */  sub.s     $f4, $f28, $f4
-/* 37524 8005C124 460A0001 */  sub.s     $f0, $f0, $f10
-/* 37528 8005C128 46002102 */  mul.s     $f4, $f4, $f0
-/* 3752C 8005C12C 00000000 */  nop
-/* 37530 8005C130 46064201 */  sub.s     $f8, $f8, $f6
-/* 37534 8005C134 C4A00008 */  lwc1      $f0, 8($a1)
-/* 37538 8005C138 46009001 */  sub.s     $f0, $f18, $f0
-/* 3753C 8005C13C 46080002 */  mul.s     $f0, $f0, $f8
-/* 37540 8005C140 00000000 */  nop
-/* 37544 8005C144 46041080 */  add.s     $f2, $f2, $f4
-/* 37548 8005C148 080170D4 */  j         .L8005C350
-/* 3754C 8005C14C 46001080 */   add.s    $f2, $f2, $f0
-.L8005C150:
-/* 37550 8005C150 3C01800A */  lui       $at, %hi(D_800A423C)
-/* 37554 8005C154 C430423C */  lwc1      $f16, %lo(D_800A423C)($at)
-/* 37558 8005C158 46105002 */  mul.s     $f0, $f10, $f16
-/* 3755C 8005C15C 00000000 */  nop
-/* 37560 8005C160 3C01800A */  lui       $at, %hi(D_800A4240)
-/* 37564 8005C164 C42E4240 */  lwc1      $f14, %lo(D_800A4240)($at)
-/* 37568 8005C168 460E4102 */  mul.s     $f4, $f8, $f14
-/* 3756C 8005C16C 00000000 */  nop
-/* 37570 8005C170 3C01800A */  lui       $at, %hi(D_800A4244)
-/* 37574 8005C174 C42C4244 */  lwc1      $f12, %lo(D_800A4244)($at)
-/* 37578 8005C178 460C3082 */  mul.s     $f2, $f6, $f12
-/* 3757C 8005C17C 00000000 */  nop
-/* 37580 8005C180 46040000 */  add.s     $f0, $f0, $f4
-/* 37584 8005C184 46020000 */  add.s     $f0, $f0, $f2
-/* 37588 8005C188 46140002 */  mul.s     $f0, $f0, $f20
-/* 3758C 8005C18C 00000000 */  nop
-/* 37590 8005C190 4480F000 */  mtc1      $zero, $f30
-/* 37594 8005C194 00000000 */  nop
-/* 37598 8005C198 4600F03E */  c.le.s    $f30, $f0
-/* 3759C 8005C19C 00000000 */  nop
-/* 375A0 8005C1A0 450100B6 */  bc1t      .L8005C47C
-/* 375A4 8005C1A4 0000102D */   daddu    $v0, $zero, $zero
-/* 375A8 8005C1A8 C4880014 */  lwc1      $f8, 0x14($a0)
-/* 375AC 8005C1AC 460E4002 */  mul.s     $f0, $f8, $f14
-/* 375B0 8005C1B0 00000000 */  nop
-/* 375B4 8005C1B4 C4840010 */  lwc1      $f4, 0x10($a0)
-/* 375B8 8005C1B8 460C2082 */  mul.s     $f2, $f4, $f12
-/* 375BC 8005C1BC 00000000 */  nop
-/* 375C0 8005C1C0 46104202 */  mul.s     $f8, $f8, $f16
-/* 375C4 8005C1C4 00000000 */  nop
-/* 375C8 8005C1C8 46102102 */  mul.s     $f4, $f4, $f16
-/* 375CC 8005C1CC 00000000 */  nop
-/* 375D0 8005C1D0 46020001 */  sub.s     $f0, $f0, $f2
-/* 375D4 8005C1D4 C486000C */  lwc1      $f6, 0xc($a0)
-/* 375D8 8005C1D8 460C3082 */  mul.s     $f2, $f6, $f12
-/* 375DC 8005C1DC 00000000 */  nop
-/* 375E0 8005C1E0 460E3182 */  mul.s     $f6, $f6, $f14
-/* 375E4 8005C1E4 00000000 */  nop
-/* 375E8 8005C1E8 C7B20008 */  lwc1      $f18, 8($sp)
-/* 375EC 8005C1EC 46009002 */  mul.s     $f0, $f18, $f0
-/* 375F0 8005C1F0 00000000 */  nop
-/* 375F4 8005C1F4 46081081 */  sub.s     $f2, $f2, $f8
-/* 375F8 8005C1F8 4602C082 */  mul.s     $f2, $f24, $f2
-/* 375FC 8005C1FC 00000000 */  nop
-/* 37600 8005C200 46062101 */  sub.s     $f4, $f4, $f6
-/* 37604 8005C204 4604B102 */  mul.s     $f4, $f22, $f4
-/* 37608 8005C208 00000000 */  nop
-/* 3760C 8005C20C 46020000 */  add.s     $f0, $f0, $f2
-/* 37610 8005C210 46040000 */  add.s     $f0, $f0, $f4
-/* 37614 8005C214 46140002 */  mul.s     $f0, $f0, $f20
-/* 37618 8005C218 00000000 */  nop
-/* 3761C 8005C21C 461E003C */  c.lt.s    $f0, $f30
-/* 37620 8005C220 00000000 */  nop
-/* 37624 8005C224 45010095 */  bc1t      .L8005C47C
-/* 37628 8005C228 00000000 */   nop
-/* 3762C 8005C22C C48A0020 */  lwc1      $f10, 0x20($a0)
-/* 37630 8005C230 460E5002 */  mul.s     $f0, $f10, $f14
-/* 37634 8005C234 00000000 */  nop
-/* 37638 8005C238 C488001C */  lwc1      $f8, 0x1c($a0)
-/* 3763C 8005C23C 460C4102 */  mul.s     $f4, $f8, $f12
-/* 37640 8005C240 00000000 */  nop
-/* 37644 8005C244 46105282 */  mul.s     $f10, $f10, $f16
-/* 37648 8005C248 00000000 */  nop
-/* 3764C 8005C24C 46104202 */  mul.s     $f8, $f8, $f16
-/* 37650 8005C250 00000000 */  nop
-/* 37654 8005C254 C4620000 */  lwc1      $f2, ($v1)
-/* 37658 8005C258 4602D081 */  sub.s     $f2, $f26, $f2
-/* 3765C 8005C25C 46040001 */  sub.s     $f0, $f0, $f4
-/* 37660 8005C260 46001082 */  mul.s     $f2, $f2, $f0
-/* 37664 8005C264 00000000 */  nop
-/* 37668 8005C268 C4860018 */  lwc1      $f6, 0x18($a0)
-/* 3766C 8005C26C 460C3002 */  mul.s     $f0, $f6, $f12
-/* 37670 8005C270 00000000 */  nop
-/* 37674 8005C274 460E3182 */  mul.s     $f6, $f6, $f14
-/* 37678 8005C278 00000000 */  nop
-/* 3767C 8005C27C C4640004 */  lwc1      $f4, 4($v1)
-/* 37680 8005C280 4604E101 */  sub.s     $f4, $f28, $f4
-/* 37684 8005C284 460A0001 */  sub.s     $f0, $f0, $f10
-/* 37688 8005C288 46002102 */  mul.s     $f4, $f4, $f0
-/* 3768C 8005C28C 00000000 */  nop
-/* 37690 8005C290 C7B20000 */  lwc1      $f18, ($sp)
-/* 37694 8005C294 46064201 */  sub.s     $f8, $f8, $f6
-/* 37698 8005C298 C4600008 */  lwc1      $f0, 8($v1)
-/* 3769C 8005C29C 46009001 */  sub.s     $f0, $f18, $f0
-/* 376A0 8005C2A0 46080002 */  mul.s     $f0, $f0, $f8
-/* 376A4 8005C2A4 00000000 */  nop
-/* 376A8 8005C2A8 46041080 */  add.s     $f2, $f2, $f4
-/* 376AC 8005C2AC 46001080 */  add.s     $f2, $f2, $f0
-/* 376B0 8005C2B0 46141082 */  mul.s     $f2, $f2, $f20
-/* 376B4 8005C2B4 00000000 */  nop
-/* 376B8 8005C2B8 461E103C */  c.lt.s    $f2, $f30
-/* 376BC 8005C2BC 00000000 */  nop
-/* 376C0 8005C2C0 4501006E */  bc1t      .L8005C47C
-/* 376C4 8005C2C4 00000000 */   nop
-/* 376C8 8005C2C8 C48A002C */  lwc1      $f10, 0x2c($a0)
-/* 376CC 8005C2CC 460E5002 */  mul.s     $f0, $f10, $f14
-/* 376D0 8005C2D0 00000000 */  nop
-/* 376D4 8005C2D4 C4880028 */  lwc1      $f8, 0x28($a0)
-/* 376D8 8005C2D8 460C4102 */  mul.s     $f4, $f8, $f12
-/* 376DC 8005C2DC 00000000 */  nop
-/* 376E0 8005C2E0 46105282 */  mul.s     $f10, $f10, $f16
-/* 376E4 8005C2E4 00000000 */  nop
-/* 376E8 8005C2E8 46104202 */  mul.s     $f8, $f8, $f16
-/* 376EC 8005C2EC 00000000 */  nop
-/* 376F0 8005C2F0 C4A20000 */  lwc1      $f2, ($a1)
-/* 376F4 8005C2F4 4602D081 */  sub.s     $f2, $f26, $f2
-/* 376F8 8005C2F8 46040001 */  sub.s     $f0, $f0, $f4
-/* 376FC 8005C2FC 46001082 */  mul.s     $f2, $f2, $f0
-/* 37700 8005C300 00000000 */  nop
-/* 37704 8005C304 C4860024 */  lwc1      $f6, 0x24($a0)
-/* 37708 8005C308 460C3002 */  mul.s     $f0, $f6, $f12
-/* 3770C 8005C30C 00000000 */  nop
-/* 37710 8005C310 460E3182 */  mul.s     $f6, $f6, $f14
-/* 37714 8005C314 00000000 */  nop
-/* 37718 8005C318 C4A40004 */  lwc1      $f4, 4($a1)
-/* 3771C 8005C31C 4604E101 */  sub.s     $f4, $f28, $f4
-/* 37720 8005C320 460A0001 */  sub.s     $f0, $f0, $f10
-/* 37724 8005C324 46002102 */  mul.s     $f4, $f4, $f0
-/* 37728 8005C328 00000000 */  nop
-/* 3772C 8005C32C 46064201 */  sub.s     $f8, $f8, $f6
-/* 37730 8005C330 C4A00008 */  lwc1      $f0, 8($a1)
-/* 37734 8005C334 46009001 */  sub.s     $f0, $f18, $f0
-/* 37738 8005C338 46080002 */  mul.s     $f0, $f0, $f8
-/* 3773C 8005C33C 00000000 */  nop
-/* 37740 8005C340 46041080 */  add.s     $f2, $f2, $f4
-/* 37744 8005C344 46001080 */  add.s     $f2, $f2, $f0
-/* 37748 8005C348 46141082 */  mul.s     $f2, $f2, $f20
-/* 3774C 8005C34C 00000000 */  nop
-.L8005C350:
-/* 37750 8005C350 461E103C */  c.lt.s    $f2, $f30
-/* 37754 8005C354 00000000 */  nop
-/* 37758 8005C358 45030048 */  bc1tl     .L8005C47C
-/* 3775C 8005C35C 0000102D */   daddu    $v0, $zero, $zero
-/* 37760 8005C360 C4860030 */  lwc1      $f6, 0x30($a0)
-/* 37764 8005C364 3C01800A */  lui       $at, %hi(D_800A423C)
-/* 37768 8005C368 C420423C */  lwc1      $f0, %lo(D_800A423C)($at)
-/* 3776C 8005C36C 46003182 */  mul.s     $f6, $f6, $f0
-/* 37770 8005C370 00000000 */  nop
-/* 37774 8005C374 C4820034 */  lwc1      $f2, 0x34($a0)
-/* 37778 8005C378 3C01800A */  lui       $at, %hi(D_800A4240)
-/* 3777C 8005C37C C4204240 */  lwc1      $f0, %lo(D_800A4240)($at)
-/* 37780 8005C380 46001082 */  mul.s     $f2, $f2, $f0
-/* 37784 8005C384 00000000 */  nop
-/* 37788 8005C388 C4840038 */  lwc1      $f4, 0x38($a0)
-/* 3778C 8005C38C 3C01800A */  lui       $at, %hi(D_800A4244)
-/* 37790 8005C390 C4204244 */  lwc1      $f0, %lo(D_800A4244)($at)
-/* 37794 8005C394 46002102 */  mul.s     $f4, $f4, $f0
-/* 37798 8005C398 00000000 */  nop
-/* 3779C 8005C39C 3C01800A */  lui       $at, %hi(D_800A4254)
-/* 377A0 8005C3A0 C4284254 */  lwc1      $f8, %lo(D_800A4254)($at)
-/* 377A4 8005C3A4 46023180 */  add.s     $f6, $f6, $f2
-/* 377A8 8005C3A8 44800000 */  mtc1      $zero, $f0
-/* 377AC 8005C3AC 00000000 */  nop
-/* 377B0 8005C3B0 4608003E */  c.le.s    $f0, $f8
-/* 377B4 8005C3B4 00000000 */  nop
-/* 377B8 8005C3B8 45000007 */  bc1f      .L8005C3D8
-/* 377BC 8005C3BC 46043180 */   add.s    $f6, $f6, $f4
-/* 377C0 8005C3C0 4600A007 */  neg.s     $f0, $f20
-/* 377C4 8005C3C4 46060003 */  div.s     $f0, $f0, $f6
-/* 377C8 8005C3C8 4600403E */  c.le.s    $f8, $f0
-/* 377CC 8005C3CC 00000000 */  nop
-/* 377D0 8005C3D0 4501002A */  bc1t      .L8005C47C
-/* 377D4 8005C3D4 0000102D */   daddu    $v0, $zero, $zero
-.L8005C3D8:
-/* 377D8 8005C3D8 4600A007 */  neg.s     $f0, $f20
-/* 377DC 8005C3DC 3C01800A */  lui       $at, %hi(D_800A423C)
-/* 377E0 8005C3E0 C422423C */  lwc1      $f2, %lo(D_800A423C)($at)
-/* 377E4 8005C3E4 46060003 */  div.s     $f0, $f0, $f6
-/* 377E8 8005C3E8 46001082 */  mul.s     $f2, $f2, $f0
-/* 377EC 8005C3EC 00000000 */  nop
-/* 377F0 8005C3F0 3C01800A */  lui       $at, %hi(D_800A4240)
-/* 377F4 8005C3F4 C42A4240 */  lwc1      $f10, %lo(D_800A4240)($at)
-/* 377F8 8005C3F8 46005282 */  mul.s     $f10, $f10, $f0
-/* 377FC 8005C3FC 00000000 */  nop
-/* 37800 8005C400 3C01800A */  lui       $at, %hi(D_800A4230)
-/* 37804 8005C404 C42C4230 */  lwc1      $f12, %lo(D_800A4230)($at)
-/* 37808 8005C408 3C01800A */  lui       $at, %hi(D_800A4244)
-/* 3780C 8005C40C C4284244 */  lwc1      $f8, %lo(D_800A4244)($at)
-/* 37810 8005C410 C4840030 */  lwc1      $f4, 0x30($a0)
-/* 37814 8005C414 C4860038 */  lwc1      $f6, 0x38($a0)
-/* 37818 8005C418 46004202 */  mul.s     $f8, $f8, $f0
-/* 3781C 8005C41C 00000000 */  nop
-/* 37820 8005C420 3C01800A */  lui       $at, %hi(D_800A4254)
-/* 37824 8005C424 E4204254 */  swc1      $f0, %lo(D_800A4254)($at)
-/* 37828 8005C428 3C01800A */  lui       $at, %hi(D_800A4234)
-/* 3782C 8005C42C C4204234 */  lwc1      $f0, %lo(D_800A4234)($at)
-/* 37830 8005C430 24020001 */  addiu     $v0, $zero, 1
-/* 37834 8005C434 3C01800A */  lui       $at, %hi(D_800A4258)
-/* 37838 8005C438 E4244258 */  swc1      $f4, %lo(D_800A4258)($at)
-/* 3783C 8005C43C 46026300 */  add.s     $f12, $f12, $f2
-/* 37840 8005C440 C4840034 */  lwc1      $f4, 0x34($a0)
-/* 37844 8005C444 3C01800A */  lui       $at, %hi(D_800A4238)
-/* 37848 8005C448 C4224238 */  lwc1      $f2, %lo(D_800A4238)($at)
-/* 3784C 8005C44C 460A0000 */  add.s     $f0, $f0, $f10
-/* 37850 8005C450 3C01800A */  lui       $at, %hi(D_800A4260)
-/* 37854 8005C454 E4264260 */  swc1      $f6, %lo(D_800A4260)($at)
-/* 37858 8005C458 3C01800A */  lui       $at, %hi(D_800A425C)
-/* 3785C 8005C45C E424425C */  swc1      $f4, %lo(D_800A425C)($at)
-/* 37860 8005C460 46081080 */  add.s     $f2, $f2, $f8
-/* 37864 8005C464 3C01800A */  lui       $at, %hi(D_800A4248)
-/* 37868 8005C468 E42C4248 */  swc1      $f12, %lo(D_800A4248)($at)
-/* 3786C 8005C46C 3C01800A */  lui       $at, %hi(D_800A424C)
-/* 37870 8005C470 E420424C */  swc1      $f0, %lo(D_800A424C)($at)
-/* 37874 8005C474 3C01800A */  lui       $at, %hi(D_800A4250)
-/* 37878 8005C478 E4224250 */  swc1      $f2, %lo(D_800A4250)($at)
-.L8005C47C:
-/* 3787C 8005C47C D7BE0038 */  ldc1      $f30, 0x38($sp)
-/* 37880 8005C480 D7BC0030 */  ldc1      $f28, 0x30($sp)
-/* 37884 8005C484 D7BA0028 */  ldc1      $f26, 0x28($sp)
-/* 37888 8005C488 D7B80020 */  ldc1      $f24, 0x20($sp)
-/* 3788C 8005C48C D7B60018 */  ldc1      $f22, 0x18($sp)
-/* 37890 8005C490 D7B40010 */  ldc1      $f20, 0x10($sp)
-/* 37894 8005C494 03E00008 */  jr        $ra
-/* 37898 8005C498 27BD0040 */   addiu    $sp, $sp, 0x40
diff --git a/ver/us/asm/nonmatchings/362a0_len_2f70/test_ray_zones.s b/ver/us/asm/nonmatchings/362a0_len_2f70/test_ray_zones.s
deleted file mode 100644
index 7bb8e47716..0000000000
--- a/ver/us/asm/nonmatchings/362a0_len_2f70/test_ray_zones.s
+++ /dev/null
@@ -1,120 +0,0 @@
-.set noat      # allow manual use of $at
-.set noreorder # don't insert nops after branches
-
-glabel test_ray_zones
-/* 38524 8005D124 27BDFFC8 */  addiu     $sp, $sp, -0x38
-/* 38528 8005D128 C7A00048 */  lwc1      $f0, 0x48($sp)
-/* 3852C 8005D12C C7A2004C */  lwc1      $f2, 0x4c($sp)
-/* 38530 8005D130 AFBE0030 */  sw        $fp, 0x30($sp)
-/* 38534 8005D134 8FBE005C */  lw        $fp, 0x5c($sp)
-/* 38538 8005D138 AFB50024 */  sw        $s5, 0x24($sp)
-/* 3853C 8005D13C 3C15800E */  lui       $s5, %hi(D_800D91D0)
-/* 38540 8005D140 26B591D0 */  addiu     $s5, $s5, %lo(D_800D91D0)
-/* 38544 8005D144 AFBF0034 */  sw        $ra, 0x34($sp)
-/* 38548 8005D148 AFB7002C */  sw        $s7, 0x2c($sp)
-/* 3854C 8005D14C AFB60028 */  sw        $s6, 0x28($sp)
-/* 38550 8005D150 AFB40020 */  sw        $s4, 0x20($sp)
-/* 38554 8005D154 AFB3001C */  sw        $s3, 0x1c($sp)
-/* 38558 8005D158 AFB20018 */  sw        $s2, 0x18($sp)
-/* 3855C 8005D15C AFB10014 */  sw        $s1, 0x14($sp)
-/* 38560 8005D160 AFB00010 */  sw        $s0, 0x10($sp)
-/* 38564 8005D164 86A2000C */  lh        $v0, 0xc($s5)
-/* 38568 8005D168 2416FFFF */  addiu     $s6, $zero, -1
-/* 3856C 8005D16C 3C01800A */  lui       $at, %hi(D_800A423C)
-/* 38570 8005D170 AC27423C */  sw        $a3, %lo(D_800A423C)($at)
-/* 38574 8005D174 3C01800A */  lui       $at, %hi(D_800A4230)
-/* 38578 8005D178 E42C4230 */  swc1      $f12, %lo(D_800A4230)($at)
-/* 3857C 8005D17C 3C01800A */  lui       $at, %hi(D_800A4234)
-/* 38580 8005D180 E42E4234 */  swc1      $f14, %lo(D_800A4234)($at)
-/* 38584 8005D184 3C01800A */  lui       $at, %hi(D_800A4238)
-/* 38588 8005D188 AC264238 */  sw        $a2, %lo(D_800A4238)($at)
-/* 3858C 8005D18C 3C01800A */  lui       $at, %hi(D_800A4240)
-/* 38590 8005D190 E4204240 */  swc1      $f0, %lo(D_800A4240)($at)
-/* 38594 8005D194 3C01800A */  lui       $at, %hi(D_800A4244)
-/* 38598 8005D198 E4224244 */  swc1      $f2, %lo(D_800A4244)($at)
-/* 3859C 8005D19C C7C00000 */  lwc1      $f0, ($fp)
-/* 385A0 8005D1A0 3C01800A */  lui       $at, %hi(D_800A4254)
-/* 385A4 8005D1A4 E4204254 */  swc1      $f0, %lo(D_800A4254)($at)
-/* 385A8 8005D1A8 18400022 */  blez      $v0, .L8005D234
-/* 385AC 8005D1AC 0000982D */   daddu    $s3, $zero, $zero
-/* 385B0 8005D1B0 3C170001 */  lui       $s7, 1
-/* 385B4 8005D1B4 0260A02D */  daddu     $s4, $s3, $zero
-.L8005D1B8:
-/* 385B8 8005D1B8 8EA20004 */  lw        $v0, 4($s5)
-/* 385BC 8005D1BC 00549021 */  addu      $s2, $v0, $s4
-/* 385C0 8005D1C0 8E420000 */  lw        $v0, ($s2)
-/* 385C4 8005D1C4 00571024 */  and       $v0, $v0, $s7
-/* 385C8 8005D1C8 14400015 */  bnez      $v0, .L8005D220
-/* 385CC 8005D1CC 00000000 */   nop
-/* 385D0 8005D1D0 8643000A */  lh        $v1, 0xa($s2)
-/* 385D4 8005D1D4 10600012 */  beqz      $v1, .L8005D220
-/* 385D8 8005D1D8 00000000 */   nop
-/* 385DC 8005D1DC 8E420010 */  lw        $v0, 0x10($s2)
-/* 385E0 8005D1E0 1040000F */  beqz      $v0, .L8005D220
-/* 385E4 8005D1E4 00000000 */   nop
-/* 385E8 8005D1E8 8E51000C */  lw        $s1, 0xc($s2)
-/* 385EC 8005D1EC 1860000C */  blez      $v1, .L8005D220
-/* 385F0 8005D1F0 0000802D */   daddu    $s0, $zero, $zero
-/* 385F4 8005D1F4 0220202D */  daddu     $a0, $s1, $zero
-.L8005D1F8:
-/* 385F8 8005D1F8 8EA50000 */  lw        $a1, ($s5)
-/* 385FC 8005D1FC 0C017127 */  jal       test_down_ray_triangle
-/* 38600 8005D200 26310040 */   addiu    $s1, $s1, 0x40
-/* 38604 8005D204 54400001 */  bnel      $v0, $zero, .L8005D20C
-/* 38608 8005D208 0260B02D */   daddu    $s6, $s3, $zero
-.L8005D20C:
-/* 3860C 8005D20C 8642000A */  lh        $v0, 0xa($s2)
-/* 38610 8005D210 26100001 */  addiu     $s0, $s0, 1
-/* 38614 8005D214 0202102A */  slt       $v0, $s0, $v0
-/* 38618 8005D218 1440FFF7 */  bnez      $v0, .L8005D1F8
-/* 3861C 8005D21C 0220202D */   daddu    $a0, $s1, $zero
-.L8005D220:
-/* 38620 8005D220 86A2000C */  lh        $v0, 0xc($s5)
-/* 38624 8005D224 26730001 */  addiu     $s3, $s3, 1
-/* 38628 8005D228 0262102A */  slt       $v0, $s3, $v0
-/* 3862C 8005D22C 1440FFE2 */  bnez      $v0, .L8005D1B8
-/* 38630 8005D230 2694001C */   addiu    $s4, $s4, 0x1c
-.L8005D234:
-/* 38634 8005D234 06C0001D */  bltz      $s6, .L8005D2AC
-/* 38638 8005D238 02C0102D */   daddu    $v0, $s6, $zero
-/* 3863C 8005D23C 3C01800A */  lui       $at, %hi(D_800A4248)
-/* 38640 8005D240 C4204248 */  lwc1      $f0, %lo(D_800A4248)($at)
-/* 38644 8005D244 8FA20050 */  lw        $v0, 0x50($sp)
-/* 38648 8005D248 E4400000 */  swc1      $f0, ($v0)
-/* 3864C 8005D24C 3C01800A */  lui       $at, %hi(D_800A424C)
-/* 38650 8005D250 C420424C */  lwc1      $f0, %lo(D_800A424C)($at)
-/* 38654 8005D254 8FA20054 */  lw        $v0, 0x54($sp)
-/* 38658 8005D258 E4400000 */  swc1      $f0, ($v0)
-/* 3865C 8005D25C 3C01800A */  lui       $at, %hi(D_800A4250)
-/* 38660 8005D260 C4204250 */  lwc1      $f0, %lo(D_800A4250)($at)
-/* 38664 8005D264 8FA20058 */  lw        $v0, 0x58($sp)
-/* 38668 8005D268 E4400000 */  swc1      $f0, ($v0)
-/* 3866C 8005D26C 3C01800A */  lui       $at, %hi(D_800A4254)
-/* 38670 8005D270 C4204254 */  lwc1      $f0, %lo(D_800A4254)($at)
-/* 38674 8005D274 E7C00000 */  swc1      $f0, ($fp)
-/* 38678 8005D278 3C01800A */  lui       $at, %hi(D_800A4258)
-/* 3867C 8005D27C C4204258 */  lwc1      $f0, %lo(D_800A4258)($at)
-/* 38680 8005D280 8FA20060 */  lw        $v0, 0x60($sp)
-/* 38684 8005D284 E4400000 */  swc1      $f0, ($v0)
-/* 38688 8005D288 3C01800A */  lui       $at, %hi(D_800A425C)
-/* 3868C 8005D28C C420425C */  lwc1      $f0, %lo(D_800A425C)($at)
-/* 38690 8005D290 8FA20064 */  lw        $v0, 0x64($sp)
-/* 38694 8005D294 E4400000 */  swc1      $f0, ($v0)
-/* 38698 8005D298 3C01800A */  lui       $at, %hi(D_800A4260)
-/* 3869C 8005D29C C4204260 */  lwc1      $f0, %lo(D_800A4260)($at)
-/* 386A0 8005D2A0 8FA30068 */  lw        $v1, 0x68($sp)
-/* 386A4 8005D2A4 02C0102D */  daddu     $v0, $s6, $zero
-/* 386A8 8005D2A8 E4600000 */  swc1      $f0, ($v1)
-.L8005D2AC:
-/* 386AC 8005D2AC 8FBF0034 */  lw        $ra, 0x34($sp)
-/* 386B0 8005D2B0 8FBE0030 */  lw        $fp, 0x30($sp)
-/* 386B4 8005D2B4 8FB7002C */  lw        $s7, 0x2c($sp)
-/* 386B8 8005D2B8 8FB60028 */  lw        $s6, 0x28($sp)
-/* 386BC 8005D2BC 8FB50024 */  lw        $s5, 0x24($sp)
-/* 386C0 8005D2C0 8FB40020 */  lw        $s4, 0x20($sp)
-/* 386C4 8005D2C4 8FB3001C */  lw        $s3, 0x1c($sp)
-/* 386C8 8005D2C8 8FB20018 */  lw        $s2, 0x18($sp)
-/* 386CC 8005D2CC 8FB10014 */  lw        $s1, 0x14($sp)
-/* 386D0 8005D2D0 8FB00010 */  lw        $s0, 0x10($sp)
-/* 386D4 8005D2D4 03E00008 */  jr        $ra
-/* 386D8 8005D2D8 27BD0038 */   addiu    $sp, $sp, 0x38
diff --git a/ver/us/asm/nonmatchings/362a0_len_2f70/test_up_ray_collider.s b/ver/us/asm/nonmatchings/362a0_len_2f70/test_up_ray_collider.s
deleted file mode 100644
index 653ab87fa6..0000000000
--- a/ver/us/asm/nonmatchings/362a0_len_2f70/test_up_ray_collider.s
+++ /dev/null
@@ -1,98 +0,0 @@
-.set noat      # allow manual use of $at
-.set noreorder # don't insert nops after branches
-
-glabel test_up_ray_collider
-/* 386DC 8005D2DC 27BDFFA8 */  addiu     $sp, $sp, -0x58
-/* 386E0 8005D2E0 F7B80040 */  sdc1      $f24, 0x40($sp)
-/* 386E4 8005D2E4 4486C000 */  mtc1      $a2, $f24
-/* 386E8 8005D2E8 F7BA0048 */  sdc1      $f26, 0x48($sp)
-/* 386EC 8005D2EC 4487D000 */  mtc1      $a3, $f26
-/* 386F0 8005D2F0 C7AC0070 */  lwc1      $f12, 0x70($sp)
-/* 386F4 8005D2F4 3C0140C9 */  lui       $at, 0x40c9
-/* 386F8 8005D2F8 34210FD0 */  ori       $at, $at, 0xfd0
-/* 386FC 8005D2FC 44810000 */  mtc1      $at, $f0
-/* 38700 8005D300 F7BC0050 */  sdc1      $f28, 0x50($sp)
-/* 38704 8005D304 3C01BF80 */  lui       $at, 0xbf80
-/* 38708 8005D308 4481E000 */  mtc1      $at, $f28
-/* 3870C 8005D30C AFB1001C */  sw        $s1, 0x1c($sp)
-/* 38710 8005D310 0080882D */  daddu     $s1, $a0, $zero
-/* 38714 8005D314 AFB00018 */  sw        $s0, 0x18($sp)
-/* 38718 8005D318 00A0802D */  daddu     $s0, $a1, $zero
-/* 3871C 8005D31C F7B40030 */  sdc1      $f20, 0x30($sp)
-/* 38720 8005D320 C7B40068 */  lwc1      $f20, 0x68($sp)
-/* 38724 8005D324 27A50010 */  addiu     $a1, $sp, 0x10
-/* 38728 8005D328 F7B60038 */  sdc1      $f22, 0x38($sp)
-/* 3872C 8005D32C C7B6006C */  lwc1      $f22, 0x6c($sp)
-/* 38730 8005D330 46006302 */  mul.s     $f12, $f12, $f0
-/* 38734 8005D334 00000000 */  nop
-/* 38738 8005D338 3C0143B4 */  lui       $at, 0x43b4
-/* 3873C 8005D33C 44810000 */  mtc1      $at, $f0
-/* 38740 8005D340 27A60014 */  addiu     $a2, $sp, 0x14
-/* 38744 8005D344 AFBF0028 */  sw        $ra, 0x28($sp)
-/* 38748 8005D348 AFB30024 */  sw        $s3, 0x24($sp)
-/* 3874C 8005D34C AFB20020 */  sw        $s2, 0x20($sp)
-/* 38750 8005D350 0C00A82D */  jal       sin_cos_rad
-/* 38754 8005D354 46006303 */   div.s    $f12, $f12, $f0
-/* 38758 8005D358 3C13800B */  lui       $s3, %hi(gCollisionData)
-/* 3875C 8005D35C 267342E0 */  addiu     $s3, $s3, %lo(gCollisionData)
-/* 38760 8005D360 001010C0 */  sll       $v0, $s0, 3
-/* 38764 8005D364 00501023 */  subu      $v0, $v0, $s0
-/* 38768 8005D368 00021080 */  sll       $v0, $v0, 2
-/* 3876C 8005D36C 8E630004 */  lw        $v1, 4($s3)
-/* 38770 8005D370 C7A00010 */  lwc1      $f0, 0x10($sp)
-/* 38774 8005D374 00629021 */  addu      $s2, $v1, $v0
-/* 38778 8005D378 8E420000 */  lw        $v0, ($s2)
-/* 3877C 8005D37C 3C01800A */  lui       $at, %hi(D_800A4240)
-/* 38780 8005D380 AC204240 */  sw        $zero, %lo(D_800A4240)($at)
-/* 38784 8005D384 3C01800A */  lui       $at, %hi(D_800A4230)
-/* 38788 8005D388 E4384230 */  swc1      $f24, %lo(D_800A4230)($at)
-/* 3878C 8005D38C 3C01800A */  lui       $at, %hi(D_800A4234)
-/* 38790 8005D390 E43A4234 */  swc1      $f26, %lo(D_800A4234)($at)
-/* 38794 8005D394 3C01800A */  lui       $at, %hi(D_800A4238)
-/* 38798 8005D398 E4344238 */  swc1      $f20, %lo(D_800A4238)($at)
-/* 3879C 8005D39C 3C01800A */  lui       $at, %hi(D_800A4254)
-/* 387A0 8005D3A0 E4364254 */  swc1      $f22, %lo(D_800A4254)($at)
-/* 387A4 8005D3A4 3C01800A */  lui       $at, %hi(D_800A423C)
-/* 387A8 8005D3A8 E420423C */  swc1      $f0, %lo(D_800A423C)($at)
-/* 387AC 8005D3AC C7A00014 */  lwc1      $f0, 0x14($sp)
-/* 387B0 8005D3B0 00511024 */  and       $v0, $v0, $s1
-/* 387B4 8005D3B4 46000007 */  neg.s     $f0, $f0
-/* 387B8 8005D3B8 3C01800A */  lui       $at, %hi(D_800A4244)
-/* 387BC 8005D3BC E4204244 */  swc1      $f0, %lo(D_800A4244)($at)
-/* 387C0 8005D3C0 14400015 */  bnez      $v0, .L8005D418
-/* 387C4 8005D3C4 4600E006 */   mov.s    $f0, $f28
-/* 387C8 8005D3C8 8642000A */  lh        $v0, 0xa($s2)
-/* 387CC 8005D3CC 10400012 */  beqz      $v0, .L8005D418
-/* 387D0 8005D3D0 00000000 */   nop
-/* 387D4 8005D3D4 8E51000C */  lw        $s1, 0xc($s2)
-/* 387D8 8005D3D8 1840000F */  blez      $v0, .L8005D418
-/* 387DC 8005D3DC 0000802D */   daddu    $s0, $zero, $zero
-/* 387E0 8005D3E0 0220202D */  daddu     $a0, $s1, $zero
-.L8005D3E4:
-/* 387E4 8005D3E4 8E650000 */  lw        $a1, ($s3)
-/* 387E8 8005D3E8 0C0171E9 */  jal       test_up_ray_triangle
-/* 387EC 8005D3EC 26310040 */   addiu    $s1, $s1, 0x40
-/* 387F0 8005D3F0 10400003 */  beqz      $v0, .L8005D400
-/* 387F4 8005D3F4 00000000 */   nop
-/* 387F8 8005D3F8 3C01800A */  lui       $at, %hi(D_800A4254)
-/* 387FC 8005D3FC C43C4254 */  lwc1      $f28, %lo(D_800A4254)($at)
-.L8005D400:
-/* 38800 8005D400 8642000A */  lh        $v0, 0xa($s2)
-/* 38804 8005D404 26100001 */  addiu     $s0, $s0, 1
-/* 38808 8005D408 0202102A */  slt       $v0, $s0, $v0
-/* 3880C 8005D40C 1440FFF5 */  bnez      $v0, .L8005D3E4
-/* 38810 8005D410 0220202D */   daddu    $a0, $s1, $zero
-/* 38814 8005D414 4600E006 */  mov.s     $f0, $f28
-.L8005D418:
-/* 38818 8005D418 8FBF0028 */  lw        $ra, 0x28($sp)
-/* 3881C 8005D41C 8FB30024 */  lw        $s3, 0x24($sp)
-/* 38820 8005D420 8FB20020 */  lw        $s2, 0x20($sp)
-/* 38824 8005D424 8FB1001C */  lw        $s1, 0x1c($sp)
-/* 38828 8005D428 8FB00018 */  lw        $s0, 0x18($sp)
-/* 3882C 8005D42C D7BC0050 */  ldc1      $f28, 0x50($sp)
-/* 38830 8005D430 D7BA0048 */  ldc1      $f26, 0x48($sp)
-/* 38834 8005D434 D7B80040 */  ldc1      $f24, 0x40($sp)
-/* 38838 8005D438 D7B60038 */  ldc1      $f22, 0x38($sp)
-/* 3883C 8005D43C D7B40030 */  ldc1      $f20, 0x30($sp)
-/* 38840 8005D440 03E00008 */  jr        $ra
-/* 38844 8005D444 27BD0058 */   addiu    $sp, $sp, 0x58
diff --git a/ver/us/asm/nonmatchings/362a0_len_2f70/test_up_ray_triangle.s b/ver/us/asm/nonmatchings/362a0_len_2f70/test_up_ray_triangle.s
deleted file mode 100644
index f48b3021ec..0000000000
--- a/ver/us/asm/nonmatchings/362a0_len_2f70/test_up_ray_triangle.s
+++ /dev/null
@@ -1,340 +0,0 @@
-.set noat      # allow manual use of $at
-.set noreorder # don't insert nops after branches
-
-glabel test_up_ray_triangle
-/* 37BA4 8005C7A4 27BDFFD8 */  addiu     $sp, $sp, -0x28
-/* 37BA8 8005C7A8 F7BC0020 */  sdc1      $f28, 0x20($sp)
-/* 37BAC 8005C7AC F7BA0018 */  sdc1      $f26, 0x18($sp)
-/* 37BB0 8005C7B0 F7B80010 */  sdc1      $f24, 0x10($sp)
-/* 37BB4 8005C7B4 F7B60008 */  sdc1      $f22, 8($sp)
-/* 37BB8 8005C7B8 F7B40000 */  sdc1      $f20, ($sp)
-/* 37BBC 8005C7BC C4800030 */  lwc1      $f0, 0x30($a0)
-/* 37BC0 8005C7C0 44801000 */  mtc1      $zero, $f2
-/* 37BC4 8005C7C4 00000000 */  nop
-/* 37BC8 8005C7C8 46020032 */  c.eq.s    $f0, $f2
-/* 37BCC 8005C7CC 00000000 */  nop
-/* 37BD0 8005C7D0 4500000B */  bc1f      .L8005C800
-/* 37BD4 8005C7D4 00000000 */   nop
-/* 37BD8 8005C7D8 C4800034 */  lwc1      $f0, 0x34($a0)
-/* 37BDC 8005C7DC 46020032 */  c.eq.s    $f0, $f2
-/* 37BE0 8005C7E0 00000000 */  nop
-/* 37BE4 8005C7E4 45000006 */  bc1f      .L8005C800
-/* 37BE8 8005C7E8 00000000 */   nop
-/* 37BEC 8005C7EC C4800038 */  lwc1      $f0, 0x38($a0)
-/* 37BF0 8005C7F0 46020032 */  c.eq.s    $f0, $f2
-/* 37BF4 8005C7F4 00000000 */  nop
-/* 37BF8 8005C7F8 4501012E */  bc1t      .L8005CCB4
-/* 37BFC 8005C7FC 0000102D */   daddu    $v0, $zero, $zero
-.L8005C800:
-/* 37C00 8005C800 8C820000 */  lw        $v0, ($a0)
-/* 37C04 8005C804 3C01800A */  lui       $at, %hi(D_800A4230)
-/* 37C08 8005C808 C4364230 */  lwc1      $f22, %lo(D_800A4230)($at)
-/* 37C0C 8005C80C C4400000 */  lwc1      $f0, ($v0)
-/* 37C10 8005C810 4600B381 */  sub.s     $f14, $f22, $f0
-/* 37C14 8005C814 C4880030 */  lwc1      $f8, 0x30($a0)
-/* 37C18 8005C818 460E4102 */  mul.s     $f4, $f8, $f14
-/* 37C1C 8005C81C 00000000 */  nop
-/* 37C20 8005C820 3C01800A */  lui       $at, %hi(D_800A4234)
-/* 37C24 8005C824 C4384234 */  lwc1      $f24, %lo(D_800A4234)($at)
-/* 37C28 8005C828 C4400004 */  lwc1      $f0, 4($v0)
-/* 37C2C 8005C82C 4600C501 */  sub.s     $f20, $f24, $f0
-/* 37C30 8005C830 C4820034 */  lwc1      $f2, 0x34($a0)
-/* 37C34 8005C834 46141082 */  mul.s     $f2, $f2, $f20
-/* 37C38 8005C838 00000000 */  nop
-/* 37C3C 8005C83C 3C01800A */  lui       $at, %hi(D_800A4238)
-/* 37C40 8005C840 C43C4238 */  lwc1      $f28, %lo(D_800A4238)($at)
-/* 37C44 8005C844 C4400008 */  lwc1      $f0, 8($v0)
-/* 37C48 8005C848 4600E401 */  sub.s     $f16, $f28, $f0
-/* 37C4C 8005C84C C4860038 */  lwc1      $f6, 0x38($a0)
-/* 37C50 8005C850 46103002 */  mul.s     $f0, $f6, $f16
-/* 37C54 8005C854 00000000 */  nop
-/* 37C58 8005C858 8C830004 */  lw        $v1, 4($a0)
-/* 37C5C 8005C85C 46022100 */  add.s     $f4, $f4, $f2
-/* 37C60 8005C860 8C850008 */  lw        $a1, 8($a0)
-/* 37C64 8005C864 8482003C */  lh        $v0, 0x3c($a0)
-/* 37C68 8005C868 10400068 */  beqz      $v0, .L8005CA0C
-/* 37C6C 8005C86C 46002480 */   add.s    $f18, $f4, $f0
-/* 37C70 8005C870 4480D000 */  mtc1      $zero, $f26
-/* 37C74 8005C874 00000000 */  nop
-/* 37C78 8005C878 461A903C */  c.lt.s    $f18, $f26
-/* 37C7C 8005C87C 00000000 */  nop
-/* 37C80 8005C880 4503010C */  bc1tl     .L8005CCB4
-/* 37C84 8005C884 0000102D */   daddu    $v0, $zero, $zero
-/* 37C88 8005C888 3C01800A */  lui       $at, %hi(D_800A423C)
-/* 37C8C 8005C88C C42C423C */  lwc1      $f12, %lo(D_800A423C)($at)
-/* 37C90 8005C890 460C4002 */  mul.s     $f0, $f8, $f12
-/* 37C94 8005C894 00000000 */  nop
-/* 37C98 8005C898 3C01800A */  lui       $at, %hi(D_800A4244)
-/* 37C9C 8005C89C C42A4244 */  lwc1      $f10, %lo(D_800A4244)($at)
-/* 37CA0 8005C8A0 460A3082 */  mul.s     $f2, $f6, $f10
-/* 37CA4 8005C8A4 00000000 */  nop
-/* 37CA8 8005C8A8 46020000 */  add.s     $f0, $f0, $f2
-/* 37CAC 8005C8AC 4600D03E */  c.le.s    $f26, $f0
-/* 37CB0 8005C8B0 00000000 */  nop
-/* 37CB4 8005C8B4 450100FF */  bc1t      .L8005CCB4
-/* 37CB8 8005C8B8 0000102D */   daddu    $v0, $zero, $zero
-/* 37CBC 8005C8BC C4860010 */  lwc1      $f6, 0x10($a0)
-/* 37CC0 8005C8C0 46003107 */  neg.s     $f4, $f6
-/* 37CC4 8005C8C4 460A2102 */  mul.s     $f4, $f4, $f10
-/* 37CC8 8005C8C8 00000000 */  nop
-/* 37CCC 8005C8CC C480000C */  lwc1      $f0, 0xc($a0)
-/* 37CD0 8005C8D0 460A0002 */  mul.s     $f0, $f0, $f10
-/* 37CD4 8005C8D4 00000000 */  nop
-/* 37CD8 8005C8D8 C4820014 */  lwc1      $f2, 0x14($a0)
-/* 37CDC 8005C8DC 460C1082 */  mul.s     $f2, $f2, $f12
-/* 37CE0 8005C8E0 00000000 */  nop
-/* 37CE4 8005C8E4 460C3182 */  mul.s     $f6, $f6, $f12
-/* 37CE8 8005C8E8 00000000 */  nop
-/* 37CEC 8005C8EC 46047102 */  mul.s     $f4, $f14, $f4
-/* 37CF0 8005C8F0 00000000 */  nop
-/* 37CF4 8005C8F4 46068182 */  mul.s     $f6, $f16, $f6
-/* 37CF8 8005C8F8 00000000 */  nop
-/* 37CFC 8005C8FC 46020001 */  sub.s     $f0, $f0, $f2
-/* 37D00 8005C900 4600A002 */  mul.s     $f0, $f20, $f0
-/* 37D04 8005C904 00000000 */  nop
-/* 37D08 8005C908 46002100 */  add.s     $f4, $f4, $f0
-/* 37D0C 8005C90C 46062100 */  add.s     $f4, $f4, $f6
-/* 37D10 8005C910 461A203C */  c.lt.s    $f4, $f26
-/* 37D14 8005C914 00000000 */  nop
-/* 37D18 8005C918 450100E6 */  bc1t      .L8005CCB4
-/* 37D1C 8005C91C 00000000 */   nop
-/* 37D20 8005C920 C488001C */  lwc1      $f8, 0x1c($a0)
-/* 37D24 8005C924 46004007 */  neg.s     $f0, $f8
-/* 37D28 8005C928 460A0002 */  mul.s     $f0, $f0, $f10
-/* 37D2C 8005C92C 00000000 */  nop
-/* 37D30 8005C930 C4840018 */  lwc1      $f4, 0x18($a0)
-/* 37D34 8005C934 460A2102 */  mul.s     $f4, $f4, $f10
-/* 37D38 8005C938 00000000 */  nop
-/* 37D3C 8005C93C 460C4202 */  mul.s     $f8, $f8, $f12
-/* 37D40 8005C940 00000000 */  nop
-/* 37D44 8005C944 C4620000 */  lwc1      $f2, ($v1)
-/* 37D48 8005C948 4602B081 */  sub.s     $f2, $f22, $f2
-/* 37D4C 8005C94C 46001082 */  mul.s     $f2, $f2, $f0
-/* 37D50 8005C950 00000000 */  nop
-/* 37D54 8005C954 C4800020 */  lwc1      $f0, 0x20($a0)
-/* 37D58 8005C958 460C0002 */  mul.s     $f0, $f0, $f12
-/* 37D5C 8005C95C 00000000 */  nop
-/* 37D60 8005C960 C4660004 */  lwc1      $f6, 4($v1)
-/* 37D64 8005C964 4606C181 */  sub.s     $f6, $f24, $f6
-/* 37D68 8005C968 46002101 */  sub.s     $f4, $f4, $f0
-/* 37D6C 8005C96C 46043182 */  mul.s     $f6, $f6, $f4
-/* 37D70 8005C970 00000000 */  nop
-/* 37D74 8005C974 C4600008 */  lwc1      $f0, 8($v1)
-/* 37D78 8005C978 4600E001 */  sub.s     $f0, $f28, $f0
-/* 37D7C 8005C97C 46080002 */  mul.s     $f0, $f0, $f8
-/* 37D80 8005C980 00000000 */  nop
-/* 37D84 8005C984 46061080 */  add.s     $f2, $f2, $f6
-/* 37D88 8005C988 46001080 */  add.s     $f2, $f2, $f0
-/* 37D8C 8005C98C 461A103C */  c.lt.s    $f2, $f26
-/* 37D90 8005C990 00000000 */  nop
-/* 37D94 8005C994 450100C7 */  bc1t      .L8005CCB4
-/* 37D98 8005C998 00000000 */   nop
-/* 37D9C 8005C99C C4880028 */  lwc1      $f8, 0x28($a0)
-/* 37DA0 8005C9A0 46004007 */  neg.s     $f0, $f8
-/* 37DA4 8005C9A4 460A0002 */  mul.s     $f0, $f0, $f10
-/* 37DA8 8005C9A8 00000000 */  nop
-/* 37DAC 8005C9AC C4840024 */  lwc1      $f4, 0x24($a0)
-/* 37DB0 8005C9B0 460A2102 */  mul.s     $f4, $f4, $f10
-/* 37DB4 8005C9B4 00000000 */  nop
-/* 37DB8 8005C9B8 460C4202 */  mul.s     $f8, $f8, $f12
-/* 37DBC 8005C9BC 00000000 */  nop
-/* 37DC0 8005C9C0 C4A20000 */  lwc1      $f2, ($a1)
-/* 37DC4 8005C9C4 4602B081 */  sub.s     $f2, $f22, $f2
-/* 37DC8 8005C9C8 46001082 */  mul.s     $f2, $f2, $f0
-/* 37DCC 8005C9CC 00000000 */  nop
-/* 37DD0 8005C9D0 C480002C */  lwc1      $f0, 0x2c($a0)
-/* 37DD4 8005C9D4 460C0002 */  mul.s     $f0, $f0, $f12
-/* 37DD8 8005C9D8 00000000 */  nop
-/* 37DDC 8005C9DC C4A60004 */  lwc1      $f6, 4($a1)
-/* 37DE0 8005C9E0 4606C181 */  sub.s     $f6, $f24, $f6
-/* 37DE4 8005C9E4 46002101 */  sub.s     $f4, $f4, $f0
-/* 37DE8 8005C9E8 46043182 */  mul.s     $f6, $f6, $f4
-/* 37DEC 8005C9EC 00000000 */  nop
-/* 37DF0 8005C9F0 C4A00008 */  lwc1      $f0, 8($a1)
-/* 37DF4 8005C9F4 4600E001 */  sub.s     $f0, $f28, $f0
-/* 37DF8 8005C9F8 46080002 */  mul.s     $f0, $f0, $f8
-/* 37DFC 8005C9FC 00000000 */  nop
-/* 37E00 8005CA00 46061080 */  add.s     $f2, $f2, $f6
-/* 37E04 8005CA04 080172ED */  j         .L8005CBB4
-/* 37E08 8005CA08 46001080 */   add.s    $f2, $f2, $f0
-.L8005CA0C:
-/* 37E0C 8005CA0C 3C01800A */  lui       $at, %hi(D_800A423C)
-/* 37E10 8005CA10 C42C423C */  lwc1      $f12, %lo(D_800A423C)($at)
-/* 37E14 8005CA14 460C4002 */  mul.s     $f0, $f8, $f12
-/* 37E18 8005CA18 00000000 */  nop
-/* 37E1C 8005CA1C 3C01800A */  lui       $at, %hi(D_800A4244)
-/* 37E20 8005CA20 C42A4244 */  lwc1      $f10, %lo(D_800A4244)($at)
-/* 37E24 8005CA24 460A3082 */  mul.s     $f2, $f6, $f10
-/* 37E28 8005CA28 00000000 */  nop
-/* 37E2C 8005CA2C 46020000 */  add.s     $f0, $f0, $f2
-/* 37E30 8005CA30 46120002 */  mul.s     $f0, $f0, $f18
-/* 37E34 8005CA34 00000000 */  nop
-/* 37E38 8005CA38 4480D000 */  mtc1      $zero, $f26
-/* 37E3C 8005CA3C 00000000 */  nop
-/* 37E40 8005CA40 4600D03E */  c.le.s    $f26, $f0
-/* 37E44 8005CA44 00000000 */  nop
-/* 37E48 8005CA48 4501009A */  bc1t      .L8005CCB4
-/* 37E4C 8005CA4C 0000102D */   daddu    $v0, $zero, $zero
-/* 37E50 8005CA50 C4860010 */  lwc1      $f6, 0x10($a0)
-/* 37E54 8005CA54 46003107 */  neg.s     $f4, $f6
-/* 37E58 8005CA58 460A2102 */  mul.s     $f4, $f4, $f10
-/* 37E5C 8005CA5C 00000000 */  nop
-/* 37E60 8005CA60 C480000C */  lwc1      $f0, 0xc($a0)
-/* 37E64 8005CA64 460A0002 */  mul.s     $f0, $f0, $f10
-/* 37E68 8005CA68 00000000 */  nop
-/* 37E6C 8005CA6C C4820014 */  lwc1      $f2, 0x14($a0)
-/* 37E70 8005CA70 460C1082 */  mul.s     $f2, $f2, $f12
-/* 37E74 8005CA74 00000000 */  nop
-/* 37E78 8005CA78 460C3182 */  mul.s     $f6, $f6, $f12
-/* 37E7C 8005CA7C 00000000 */  nop
-/* 37E80 8005CA80 46047102 */  mul.s     $f4, $f14, $f4
-/* 37E84 8005CA84 00000000 */  nop
-/* 37E88 8005CA88 46068182 */  mul.s     $f6, $f16, $f6
-/* 37E8C 8005CA8C 00000000 */  nop
-/* 37E90 8005CA90 46020001 */  sub.s     $f0, $f0, $f2
-/* 37E94 8005CA94 4600A002 */  mul.s     $f0, $f20, $f0
-/* 37E98 8005CA98 00000000 */  nop
-/* 37E9C 8005CA9C 46002100 */  add.s     $f4, $f4, $f0
-/* 37EA0 8005CAA0 46062100 */  add.s     $f4, $f4, $f6
-/* 37EA4 8005CAA4 46122102 */  mul.s     $f4, $f4, $f18
-/* 37EA8 8005CAA8 00000000 */  nop
-/* 37EAC 8005CAAC 461A203C */  c.lt.s    $f4, $f26
-/* 37EB0 8005CAB0 00000000 */  nop
-/* 37EB4 8005CAB4 4501007F */  bc1t      .L8005CCB4
-/* 37EB8 8005CAB8 00000000 */   nop
-/* 37EBC 8005CABC C488001C */  lwc1      $f8, 0x1c($a0)
-/* 37EC0 8005CAC0 46004007 */  neg.s     $f0, $f8
-/* 37EC4 8005CAC4 460A0002 */  mul.s     $f0, $f0, $f10
-/* 37EC8 8005CAC8 00000000 */  nop
-/* 37ECC 8005CACC C4840018 */  lwc1      $f4, 0x18($a0)
-/* 37ED0 8005CAD0 460A2102 */  mul.s     $f4, $f4, $f10
-/* 37ED4 8005CAD4 00000000 */  nop
-/* 37ED8 8005CAD8 460C4202 */  mul.s     $f8, $f8, $f12
-/* 37EDC 8005CADC 00000000 */  nop
-/* 37EE0 8005CAE0 C4620000 */  lwc1      $f2, ($v1)
-/* 37EE4 8005CAE4 4602B081 */  sub.s     $f2, $f22, $f2
-/* 37EE8 8005CAE8 46001082 */  mul.s     $f2, $f2, $f0
-/* 37EEC 8005CAEC 00000000 */  nop
-/* 37EF0 8005CAF0 C4800020 */  lwc1      $f0, 0x20($a0)
-/* 37EF4 8005CAF4 460C0002 */  mul.s     $f0, $f0, $f12
-/* 37EF8 8005CAF8 00000000 */  nop
-/* 37EFC 8005CAFC C4660004 */  lwc1      $f6, 4($v1)
-/* 37F00 8005CB00 4606C181 */  sub.s     $f6, $f24, $f6
-/* 37F04 8005CB04 46002101 */  sub.s     $f4, $f4, $f0
-/* 37F08 8005CB08 46043182 */  mul.s     $f6, $f6, $f4
-/* 37F0C 8005CB0C 00000000 */  nop
-/* 37F10 8005CB10 C4600008 */  lwc1      $f0, 8($v1)
-/* 37F14 8005CB14 4600E001 */  sub.s     $f0, $f28, $f0
-/* 37F18 8005CB18 46080002 */  mul.s     $f0, $f0, $f8
-/* 37F1C 8005CB1C 00000000 */  nop
-/* 37F20 8005CB20 46061080 */  add.s     $f2, $f2, $f6
-/* 37F24 8005CB24 46001080 */  add.s     $f2, $f2, $f0
-/* 37F28 8005CB28 46121082 */  mul.s     $f2, $f2, $f18
-/* 37F2C 8005CB2C 00000000 */  nop
-/* 37F30 8005CB30 461A103C */  c.lt.s    $f2, $f26
-/* 37F34 8005CB34 00000000 */  nop
-/* 37F38 8005CB38 4501005E */  bc1t      .L8005CCB4
-/* 37F3C 8005CB3C 00000000 */   nop
-/* 37F40 8005CB40 C4880028 */  lwc1      $f8, 0x28($a0)
-/* 37F44 8005CB44 46004007 */  neg.s     $f0, $f8
-/* 37F48 8005CB48 460A0002 */  mul.s     $f0, $f0, $f10
-/* 37F4C 8005CB4C 00000000 */  nop
-/* 37F50 8005CB50 C4840024 */  lwc1      $f4, 0x24($a0)
-/* 37F54 8005CB54 460A2102 */  mul.s     $f4, $f4, $f10
-/* 37F58 8005CB58 00000000 */  nop
-/* 37F5C 8005CB5C 460C4202 */  mul.s     $f8, $f8, $f12
-/* 37F60 8005CB60 00000000 */  nop
-/* 37F64 8005CB64 C4A20000 */  lwc1      $f2, ($a1)
-/* 37F68 8005CB68 4602B081 */  sub.s     $f2, $f22, $f2
-/* 37F6C 8005CB6C 46001082 */  mul.s     $f2, $f2, $f0
-/* 37F70 8005CB70 00000000 */  nop
-/* 37F74 8005CB74 C480002C */  lwc1      $f0, 0x2c($a0)
-/* 37F78 8005CB78 460C0002 */  mul.s     $f0, $f0, $f12
-/* 37F7C 8005CB7C 00000000 */  nop
-/* 37F80 8005CB80 C4A60004 */  lwc1      $f6, 4($a1)
-/* 37F84 8005CB84 4606C181 */  sub.s     $f6, $f24, $f6
-/* 37F88 8005CB88 46002101 */  sub.s     $f4, $f4, $f0
-/* 37F8C 8005CB8C 46043182 */  mul.s     $f6, $f6, $f4
-/* 37F90 8005CB90 00000000 */  nop
-/* 37F94 8005CB94 C4A00008 */  lwc1      $f0, 8($a1)
-/* 37F98 8005CB98 4600E001 */  sub.s     $f0, $f28, $f0
-/* 37F9C 8005CB9C 46080002 */  mul.s     $f0, $f0, $f8
-/* 37FA0 8005CBA0 00000000 */  nop
-/* 37FA4 8005CBA4 46061080 */  add.s     $f2, $f2, $f6
-/* 37FA8 8005CBA8 46001080 */  add.s     $f2, $f2, $f0
-/* 37FAC 8005CBAC 46121082 */  mul.s     $f2, $f2, $f18
-/* 37FB0 8005CBB0 00000000 */  nop
-.L8005CBB4:
-/* 37FB4 8005CBB4 461A103C */  c.lt.s    $f2, $f26
-/* 37FB8 8005CBB8 00000000 */  nop
-/* 37FBC 8005CBBC 4503003D */  bc1tl     .L8005CCB4
-/* 37FC0 8005CBC0 0000102D */   daddu    $v0, $zero, $zero
-/* 37FC4 8005CBC4 C4840030 */  lwc1      $f4, 0x30($a0)
-/* 37FC8 8005CBC8 3C01800A */  lui       $at, %hi(D_800A423C)
-/* 37FCC 8005CBCC C420423C */  lwc1      $f0, %lo(D_800A423C)($at)
-/* 37FD0 8005CBD0 46002102 */  mul.s     $f4, $f4, $f0
-/* 37FD4 8005CBD4 00000000 */  nop
-/* 37FD8 8005CBD8 C4820038 */  lwc1      $f2, 0x38($a0)
-/* 37FDC 8005CBDC 3C01800A */  lui       $at, %hi(D_800A4244)
-/* 37FE0 8005CBE0 C4204244 */  lwc1      $f0, %lo(D_800A4244)($at)
-/* 37FE4 8005CBE4 46001082 */  mul.s     $f2, $f2, $f0
-/* 37FE8 8005CBE8 00000000 */  nop
-/* 37FEC 8005CBEC 3C01800A */  lui       $at, %hi(D_800A4254)
-/* 37FF0 8005CBF0 C4264254 */  lwc1      $f6, %lo(D_800A4254)($at)
-/* 37FF4 8005CBF4 44800000 */  mtc1      $zero, $f0
-/* 37FF8 8005CBF8 00000000 */  nop
-/* 37FFC 8005CBFC 4606003E */  c.le.s    $f0, $f6
-/* 38000 8005CC00 00000000 */  nop
-/* 38004 8005CC04 45000007 */  bc1f      .L8005CC24
-/* 38008 8005CC08 46022100 */   add.s    $f4, $f4, $f2
-/* 3800C 8005CC0C 46009007 */  neg.s     $f0, $f18
-/* 38010 8005CC10 46040003 */  div.s     $f0, $f0, $f4
-/* 38014 8005CC14 4600303E */  c.le.s    $f6, $f0
-/* 38018 8005CC18 00000000 */  nop
-/* 3801C 8005CC1C 45010025 */  bc1t      .L8005CCB4
-/* 38020 8005CC20 0000102D */   daddu    $v0, $zero, $zero
-.L8005CC24:
-/* 38024 8005CC24 46009007 */  neg.s     $f0, $f18
-/* 38028 8005CC28 46040003 */  div.s     $f0, $f0, $f4
-/* 3802C 8005CC2C 3C01800A */  lui       $at, %hi(D_800A423C)
-/* 38030 8005CC30 C422423C */  lwc1      $f2, %lo(D_800A423C)($at)
-/* 38034 8005CC34 3C01800A */  lui       $at, %hi(D_800A4230)
-/* 38038 8005CC38 C4264230 */  lwc1      $f6, %lo(D_800A4230)($at)
-/* 3803C 8005CC3C 3C01800A */  lui       $at, %hi(D_800A4234)
-/* 38040 8005CC40 C42C4234 */  lwc1      $f12, %lo(D_800A4234)($at)
-/* 38044 8005CC44 3C01800A */  lui       $at, %hi(D_800A4244)
-/* 38048 8005CC48 C4244244 */  lwc1      $f4, %lo(D_800A4244)($at)
-/* 3804C 8005CC4C 46001082 */  mul.s     $f2, $f2, $f0
-/* 38050 8005CC50 00000000 */  nop
-/* 38054 8005CC54 C4880030 */  lwc1      $f8, 0x30($a0)
-/* 38058 8005CC58 C48A0034 */  lwc1      $f10, 0x34($a0)
-/* 3805C 8005CC5C 3C01800A */  lui       $at, %hi(D_800A4254)
-/* 38060 8005CC60 E4204254 */  swc1      $f0, %lo(D_800A4254)($at)
-/* 38064 8005CC64 46002102 */  mul.s     $f4, $f4, $f0
-/* 38068 8005CC68 00000000 */  nop
-/* 3806C 8005CC6C 3C01800A */  lui       $at, %hi(D_800A4238)
-/* 38070 8005CC70 C4204238 */  lwc1      $f0, %lo(D_800A4238)($at)
-/* 38074 8005CC74 24020001 */  addiu     $v0, $zero, 1
-/* 38078 8005CC78 3C01800A */  lui       $at, %hi(D_800A424C)
-/* 3807C 8005CC7C E42C424C */  swc1      $f12, %lo(D_800A424C)($at)
-/* 38080 8005CC80 3C01800A */  lui       $at, %hi(D_800A4258)
-/* 38084 8005CC84 E4284258 */  swc1      $f8, %lo(D_800A4258)($at)
-/* 38088 8005CC88 46023180 */  add.s     $f6, $f6, $f2
-/* 3808C 8005CC8C 3C01800A */  lui       $at, %hi(D_800A425C)
-/* 38090 8005CC90 E42A425C */  swc1      $f10, %lo(D_800A425C)($at)
-/* 38094 8005CC94 C4820038 */  lwc1      $f2, 0x38($a0)
-/* 38098 8005CC98 46040000 */  add.s     $f0, $f0, $f4
-/* 3809C 8005CC9C 3C01800A */  lui       $at, %hi(D_800A4260)
-/* 380A0 8005CCA0 E4224260 */  swc1      $f2, %lo(D_800A4260)($at)
-/* 380A4 8005CCA4 3C01800A */  lui       $at, %hi(D_800A4248)
-/* 380A8 8005CCA8 E4264248 */  swc1      $f6, %lo(D_800A4248)($at)
-/* 380AC 8005CCAC 3C01800A */  lui       $at, %hi(D_800A4250)
-/* 380B0 8005CCB0 E4204250 */  swc1      $f0, %lo(D_800A4250)($at)
-.L8005CCB4:
-/* 380B4 8005CCB4 D7BC0020 */  ldc1      $f28, 0x20($sp)
-/* 380B8 8005CCB8 D7BA0018 */  ldc1      $f26, 0x18($sp)
-/* 380BC 8005CCBC D7B80010 */  ldc1      $f24, 0x10($sp)
-/* 380C0 8005CCC0 D7B60008 */  ldc1      $f22, 8($sp)
-/* 380C4 8005CCC4 D7B40000 */  ldc1      $f20, ($sp)
-/* 380C8 8005CCC8 03E00008 */  jr        $ra
-/* 380CC 8005CCCC 27BD0028 */   addiu    $sp, $sp, 0x28
diff --git a/ver/us/asm/nonmatchings/362a0_len_2f70/update_collider_transform.s b/ver/us/asm/nonmatchings/362a0_len_2f70/update_collider_transform.s
deleted file mode 100644
index 9387e307fe..0000000000
--- a/ver/us/asm/nonmatchings/362a0_len_2f70/update_collider_transform.s
+++ /dev/null
@@ -1,244 +0,0 @@
-.set noat      # allow manual use of $at
-.set noreorder # don't insert nops after branches
-
-glabel update_collider_transform
-/* 36E24 8005BA24 27BDFF58 */  addiu     $sp, $sp, -0xa8
-/* 36E28 8005BA28 00042400 */  sll       $a0, $a0, 0x10
-/* 36E2C 8005BA2C 00042403 */  sra       $a0, $a0, 0x10
-/* 36E30 8005BA30 000410C0 */  sll       $v0, $a0, 3
-/* 36E34 8005BA34 00441023 */  subu      $v0, $v0, $a0
-/* 36E38 8005BA38 3C03800B */  lui       $v1, %hi(gCollisionData+0x4)
-/* 36E3C 8005BA3C 8C6342E4 */  lw        $v1, %lo(gCollisionData+0x4)($v1)
-/* 36E40 8005BA40 00021080 */  sll       $v0, $v0, 2
-/* 36E44 8005BA44 AFBF0074 */  sw        $ra, 0x74($sp)
-/* 36E48 8005BA48 AFB40070 */  sw        $s4, 0x70($sp)
-/* 36E4C 8005BA4C AFB3006C */  sw        $s3, 0x6c($sp)
-/* 36E50 8005BA50 AFB20068 */  sw        $s2, 0x68($sp)
-/* 36E54 8005BA54 AFB10064 */  sw        $s1, 0x64($sp)
-/* 36E58 8005BA58 AFB00060 */  sw        $s0, 0x60($sp)
-/* 36E5C 8005BA5C F7BE00A0 */  sdc1      $f30, 0xa0($sp)
-/* 36E60 8005BA60 F7BC0098 */  sdc1      $f28, 0x98($sp)
-/* 36E64 8005BA64 F7BA0090 */  sdc1      $f26, 0x90($sp)
-/* 36E68 8005BA68 F7B80088 */  sdc1      $f24, 0x88($sp)
-/* 36E6C 8005BA6C F7B60080 */  sdc1      $f22, 0x80($sp)
-/* 36E70 8005BA70 F7B40078 */  sdc1      $f20, 0x78($sp)
-/* 36E74 8005BA74 00629821 */  addu      $s3, $v1, $v0
-/* 36E78 8005BA78 0C046B4C */  jal       get_model_from_list_index
-/* 36E7C 8005BA7C 86640008 */   lh       $a0, 8($s3)
-/* 36E80 8005BA80 0040802D */  daddu     $s0, $v0, $zero
-/* 36E84 8005BA84 8E050004 */  lw        $a1, 4($s0)
-/* 36E88 8005BA88 14A00005 */  bnez      $a1, .L8005BAA0
-/* 36E8C 8005BA8C 26040058 */   addiu    $a0, $s0, 0x58
-/* 36E90 8005BA90 0C00A5C8 */  jal       copy_matrix
-/* 36E94 8005BA94 27A50020 */   addiu    $a1, $sp, 0x20
-/* 36E98 8005BA98 08016EAF */  j         .L8005BABC
-/* 36E9C 8005BA9C 0000902D */   daddu    $s2, $zero, $zero
-.L8005BAA0:
-/* 36EA0 8005BAA0 0C019D60 */  jal       guMtxL2F
-/* 36EA4 8005BAA4 27A40020 */   addiu    $a0, $sp, 0x20
-/* 36EA8 8005BAA8 26040058 */  addiu     $a0, $s0, 0x58
-/* 36EAC 8005BAAC 27A50020 */  addiu     $a1, $sp, 0x20
-/* 36EB0 8005BAB0 0C019D80 */  jal       guMtxCatF
-/* 36EB4 8005BAB4 00A0302D */   daddu    $a2, $a1, $zero
-/* 36EB8 8005BAB8 0000902D */  daddu     $s2, $zero, $zero
-.L8005BABC:
-/* 36EBC 8005BABC 8E74000C */  lw        $s4, 0xc($s3)
-/* 36EC0 8005BAC0 8E710018 */  lw        $s1, 0x18($s3)
-/* 36EC4 8005BAC4 3C014974 */  lui       $at, 0x4974
-/* 36EC8 8005BAC8 342123FE */  ori       $at, $at, 0x23fe
-/* 36ECC 8005BACC 4481A000 */  mtc1      $at, $f20
-/* 36ED0 8005BAD0 3C01C974 */  lui       $at, 0xc974
-/* 36ED4 8005BAD4 342123FE */  ori       $at, $at, 0x23fe
-/* 36ED8 8005BAD8 4481B000 */  mtc1      $at, $f22
-/* 36EDC 8005BADC 86620014 */  lh        $v0, 0x14($s3)
-/* 36EE0 8005BAE0 4600A686 */  mov.s     $f26, $f20
-/* 36EE4 8005BAE4 4600A606 */  mov.s     $f24, $f20
-/* 36EE8 8005BAE8 4600B786 */  mov.s     $f30, $f22
-/* 36EEC 8005BAEC 1840002C */  blez      $v0, .L8005BBA0
-/* 36EF0 8005BAF0 4600B706 */   mov.s    $f28, $f22
-/* 36EF4 8005BAF4 26300008 */  addiu     $s0, $s1, 8
-.L8005BAF8:
-/* 36EF8 8005BAF8 26220004 */  addiu     $v0, $s1, 4
-/* 36EFC 8005BAFC AFB10010 */  sw        $s1, 0x10($sp)
-/* 36F00 8005BB00 AFA20014 */  sw        $v0, 0x14($sp)
-/* 36F04 8005BB04 AFB00018 */  sw        $s0, 0x18($sp)
-/* 36F08 8005BB08 8E050004 */  lw        $a1, 4($s0)
-/* 36F0C 8005BB0C 8E060008 */  lw        $a2, 8($s0)
-/* 36F10 8005BB10 8E07000C */  lw        $a3, 0xc($s0)
-/* 36F14 8005BB14 0C019E9C */  jal       guMtxXFMF
-/* 36F18 8005BB18 27A40020 */   addiu    $a0, $sp, 0x20
-/* 36F1C 8005BB1C C6200000 */  lwc1      $f0, ($s1)
-/* 36F20 8005BB20 4618003C */  c.lt.s    $f0, $f24
-/* 36F24 8005BB24 00000000 */  nop
-/* 36F28 8005BB28 45030001 */  bc1tl     .L8005BB30
-/* 36F2C 8005BB2C 46000606 */   mov.s    $f24, $f0
-.L8005BB30:
-/* 36F30 8005BB30 4600E03C */  c.lt.s    $f28, $f0
-/* 36F34 8005BB34 00000000 */  nop
-/* 36F38 8005BB38 45030001 */  bc1tl     .L8005BB40
-/* 36F3C 8005BB3C 46000706 */   mov.s    $f28, $f0
-.L8005BB40:
-/* 36F40 8005BB40 C600FFFC */  lwc1      $f0, -4($s0)
-/* 36F44 8005BB44 461A003C */  c.lt.s    $f0, $f26
-/* 36F48 8005BB48 00000000 */  nop
-/* 36F4C 8005BB4C 45030001 */  bc1tl     .L8005BB54
-/* 36F50 8005BB50 46000686 */   mov.s    $f26, $f0
-.L8005BB54:
-/* 36F54 8005BB54 4600F03C */  c.lt.s    $f30, $f0
-/* 36F58 8005BB58 00000000 */  nop
-/* 36F5C 8005BB5C 45030001 */  bc1tl     .L8005BB64
-/* 36F60 8005BB60 46000786 */   mov.s    $f30, $f0
-.L8005BB64:
-/* 36F64 8005BB64 C6000000 */  lwc1      $f0, ($s0)
-/* 36F68 8005BB68 4614003C */  c.lt.s    $f0, $f20
-/* 36F6C 8005BB6C 00000000 */  nop
-/* 36F70 8005BB70 45030001 */  bc1tl     .L8005BB78
-/* 36F74 8005BB74 46000506 */   mov.s    $f20, $f0
-.L8005BB78:
-/* 36F78 8005BB78 4600B03C */  c.lt.s    $f22, $f0
-/* 36F7C 8005BB7C 00000000 */  nop
-/* 36F80 8005BB80 45030001 */  bc1tl     .L8005BB88
-/* 36F84 8005BB84 46000586 */   mov.s    $f22, $f0
-.L8005BB88:
-/* 36F88 8005BB88 26100018 */  addiu     $s0, $s0, 0x18
-/* 36F8C 8005BB8C 86620014 */  lh        $v0, 0x14($s3)
-/* 36F90 8005BB90 26520001 */  addiu     $s2, $s2, 1
-/* 36F94 8005BB94 0242102A */  slt       $v0, $s2, $v0
-/* 36F98 8005BB98 1440FFD7 */  bnez      $v0, .L8005BAF8
-/* 36F9C 8005BB9C 26310018 */   addiu    $s1, $s1, 0x18
-.L8005BBA0:
-/* 36FA0 8005BBA0 8E620010 */  lw        $v0, 0x10($s3)
-/* 36FA4 8005BBA4 E4580000 */  swc1      $f24, ($v0)
-/* 36FA8 8005BBA8 8E620010 */  lw        $v0, 0x10($s3)
-/* 36FAC 8005BBAC E45A0004 */  swc1      $f26, 4($v0)
-/* 36FB0 8005BBB0 8E620010 */  lw        $v0, 0x10($s3)
-/* 36FB4 8005BBB4 E4540008 */  swc1      $f20, 8($v0)
-/* 36FB8 8005BBB8 8E620010 */  lw        $v0, 0x10($s3)
-/* 36FBC 8005BBBC E45C000C */  swc1      $f28, 0xc($v0)
-/* 36FC0 8005BBC0 8E620010 */  lw        $v0, 0x10($s3)
-/* 36FC4 8005BBC4 E45E0010 */  swc1      $f30, 0x10($v0)
-/* 36FC8 8005BBC8 8E620010 */  lw        $v0, 0x10($s3)
-/* 36FCC 8005BBCC E4560014 */  swc1      $f22, 0x14($v0)
-/* 36FD0 8005BBD0 8662000A */  lh        $v0, 0xa($s3)
-/* 36FD4 8005BBD4 18400066 */  blez      $v0, .L8005BD70
-/* 36FD8 8005BBD8 0000902D */   daddu    $s2, $zero, $zero
-/* 36FDC 8005BBDC 4480D000 */  mtc1      $zero, $f26
-/* 36FE0 8005BBE0 26900038 */  addiu     $s0, $s4, 0x38
-.L8005BBE4:
-/* 36FE4 8005BBE4 8E04FFD0 */  lw        $a0, -0x30($s0)
-/* 36FE8 8005BBE8 8E820000 */  lw        $v0, ($s4)
-/* 36FEC 8005BBEC C4800000 */  lwc1      $f0, ($a0)
-/* 36FF0 8005BBF0 C4420000 */  lwc1      $f2, ($v0)
-/* 36FF4 8005BBF4 46020001 */  sub.s     $f0, $f0, $f2
-/* 36FF8 8005BBF8 E600FFD4 */  swc1      $f0, -0x2c($s0)
-/* 36FFC 8005BBFC C4800004 */  lwc1      $f0, 4($a0)
-/* 37000 8005BC00 C4420004 */  lwc1      $f2, 4($v0)
-/* 37004 8005BC04 46020001 */  sub.s     $f0, $f0, $f2
-/* 37008 8005BC08 E600FFD8 */  swc1      $f0, -0x28($s0)
-/* 3700C 8005BC0C C4800008 */  lwc1      $f0, 8($a0)
-/* 37010 8005BC10 C4420008 */  lwc1      $f2, 8($v0)
-/* 37014 8005BC14 46020001 */  sub.s     $f0, $f0, $f2
-/* 37018 8005BC18 8E03FFCC */  lw        $v1, -0x34($s0)
-/* 3701C 8005BC1C E600FFDC */  swc1      $f0, -0x24($s0)
-/* 37020 8005BC20 C4400000 */  lwc1      $f0, ($v0)
-/* 37024 8005BC24 C4620000 */  lwc1      $f2, ($v1)
-/* 37028 8005BC28 46020001 */  sub.s     $f0, $f0, $f2
-/* 3702C 8005BC2C E600FFE0 */  swc1      $f0, -0x20($s0)
-/* 37030 8005BC30 C4400004 */  lwc1      $f0, 4($v0)
-/* 37034 8005BC34 C4620004 */  lwc1      $f2, 4($v1)
-/* 37038 8005BC38 46020001 */  sub.s     $f0, $f0, $f2
-/* 3703C 8005BC3C E600FFE4 */  swc1      $f0, -0x1c($s0)
-/* 37040 8005BC40 C4400008 */  lwc1      $f0, 8($v0)
-/* 37044 8005BC44 C4620008 */  lwc1      $f2, 8($v1)
-/* 37048 8005BC48 46020001 */  sub.s     $f0, $f0, $f2
-/* 3704C 8005BC4C C60AFFD8 */  lwc1      $f10, -0x28($s0)
-/* 37050 8005BC50 E600FFE8 */  swc1      $f0, -0x18($s0)
-/* 37054 8005BC54 46000186 */  mov.s     $f6, $f0
-/* 37058 8005BC58 46065382 */  mul.s     $f14, $f10, $f6
-/* 3705C 8005BC5C 00000000 */  nop
-/* 37060 8005BC60 C604FFD4 */  lwc1      $f4, -0x2c($s0)
-/* 37064 8005BC64 46062182 */  mul.s     $f6, $f4, $f6
-/* 37068 8005BC68 00000000 */  nop
-/* 3706C 8005BC6C C608FFE4 */  lwc1      $f8, -0x1c($s0)
-/* 37070 8005BC70 46082102 */  mul.s     $f4, $f4, $f8
-/* 37074 8005BC74 00000000 */  nop
-/* 37078 8005BC78 C602FFE0 */  lwc1      $f2, -0x20($s0)
-/* 3707C 8005BC7C 46025282 */  mul.s     $f10, $f10, $f2
-/* 37080 8005BC80 00000000 */  nop
-/* 37084 8005BC84 C600FFDC */  lwc1      $f0, -0x24($s0)
-/* 37088 8005BC88 46080302 */  mul.s     $f12, $f0, $f8
-/* 3708C 8005BC8C 00000000 */  nop
-/* 37090 8005BC90 46020002 */  mul.s     $f0, $f0, $f2
-/* 37094 8005BC94 00000000 */  nop
-/* 37098 8005BC98 460A2501 */  sub.s     $f20, $f4, $f10
-/* 3709C 8005BC9C 4614A102 */  mul.s     $f4, $f20, $f20
-/* 370A0 8005BCA0 00000000 */  nop
-/* 370A4 8005BCA4 460C7601 */  sub.s     $f24, $f14, $f12
-/* 370A8 8005BCA8 4618C202 */  mul.s     $f8, $f24, $f24
-/* 370AC 8005BCAC 00000000 */  nop
-/* 370B0 8005BCB0 C4620000 */  lwc1      $f2, ($v1)
-/* 370B4 8005BCB4 46060581 */  sub.s     $f22, $f0, $f6
-/* 370B8 8005BCB8 C4800000 */  lwc1      $f0, ($a0)
-/* 370BC 8005BCBC 46001081 */  sub.s     $f2, $f2, $f0
-/* 370C0 8005BCC0 4616B182 */  mul.s     $f6, $f22, $f22
-/* 370C4 8005BCC4 00000000 */  nop
-/* 370C8 8005BCC8 E602FFEC */  swc1      $f2, -0x14($s0)
-/* 370CC 8005BCCC C4620004 */  lwc1      $f2, 4($v1)
-/* 370D0 8005BCD0 C4800004 */  lwc1      $f0, 4($a0)
-/* 370D4 8005BCD4 46001081 */  sub.s     $f2, $f2, $f0
-/* 370D8 8005BCD8 E602FFF0 */  swc1      $f2, -0x10($s0)
-/* 370DC 8005BCDC C4620008 */  lwc1      $f2, 8($v1)
-/* 370E0 8005BCE0 46064200 */  add.s     $f8, $f8, $f6
-/* 370E4 8005BCE4 C4800008 */  lwc1      $f0, 8($a0)
-/* 370E8 8005BCE8 46001081 */  sub.s     $f2, $f2, $f0
-/* 370EC 8005BCEC 46044300 */  add.s     $f12, $f8, $f4
-/* 370F0 8005BCF0 461A6032 */  c.eq.s    $f12, $f26
-/* 370F4 8005BCF4 00000000 */  nop
-/* 370F8 8005BCF8 4501000D */  bc1t      .L8005BD30
-/* 370FC 8005BCFC E602FFF4 */   swc1     $f2, -0xc($s0)
-/* 37100 8005BD00 46006084 */  sqrt.s    $f2, $f12
-/* 37104 8005BD04 46021032 */  c.eq.s    $f2, $f2
-/* 37108 8005BD08 00000000 */  nop
-/* 3710C 8005BD0C 45010004 */  bc1t      .L8005BD20
-/* 37110 8005BD10 00000000 */   nop
-/* 37114 8005BD14 0C0187BC */  jal       sqrtf
-/* 37118 8005BD18 00000000 */   nop
-/* 3711C 8005BD1C 46000086 */  mov.s     $f2, $f0
-.L8005BD20:
-/* 37120 8005BD20 3C013F80 */  lui       $at, 0x3f80
-/* 37124 8005BD24 44810000 */  mtc1      $at, $f0
-/* 37128 8005BD28 08016F4D */  j         .L8005BD34
-/* 3712C 8005BD2C 46020303 */   div.s    $f12, $f0, $f2
-.L8005BD30:
-/* 37130 8005BD30 4600D306 */  mov.s     $f12, $f26
-.L8005BD34:
-/* 37134 8005BD34 460CC002 */  mul.s     $f0, $f24, $f12
-/* 37138 8005BD38 00000000 */  nop
-/* 3713C 8005BD3C 460CB082 */  mul.s     $f2, $f22, $f12
-/* 37140 8005BD40 00000000 */  nop
-/* 37144 8005BD44 460CA102 */  mul.s     $f4, $f20, $f12
-/* 37148 8005BD48 00000000 */  nop
-/* 3714C 8005BD4C 26940040 */  addiu     $s4, $s4, 0x40
-/* 37150 8005BD50 26520001 */  addiu     $s2, $s2, 1
-/* 37154 8005BD54 E600FFF8 */  swc1      $f0, -8($s0)
-/* 37158 8005BD58 E602FFFC */  swc1      $f2, -4($s0)
-/* 3715C 8005BD5C E6040000 */  swc1      $f4, ($s0)
-/* 37160 8005BD60 8662000A */  lh        $v0, 0xa($s3)
-/* 37164 8005BD64 0242102A */  slt       $v0, $s2, $v0
-/* 37168 8005BD68 1440FF9E */  bnez      $v0, .L8005BBE4
-/* 3716C 8005BD6C 26100040 */   addiu    $s0, $s0, 0x40
-.L8005BD70:
-/* 37170 8005BD70 8FBF0074 */  lw        $ra, 0x74($sp)
-/* 37174 8005BD74 8FB40070 */  lw        $s4, 0x70($sp)
-/* 37178 8005BD78 8FB3006C */  lw        $s3, 0x6c($sp)
-/* 3717C 8005BD7C 8FB20068 */  lw        $s2, 0x68($sp)
-/* 37180 8005BD80 8FB10064 */  lw        $s1, 0x64($sp)
-/* 37184 8005BD84 8FB00060 */  lw        $s0, 0x60($sp)
-/* 37188 8005BD88 D7BE00A0 */  ldc1      $f30, 0xa0($sp)
-/* 3718C 8005BD8C D7BC0098 */  ldc1      $f28, 0x98($sp)
-/* 37190 8005BD90 D7BA0090 */  ldc1      $f26, 0x90($sp)
-/* 37194 8005BD94 D7B80088 */  ldc1      $f24, 0x88($sp)
-/* 37198 8005BD98 D7B60080 */  ldc1      $f22, 0x80($sp)
-/* 3719C 8005BD9C D7B40078 */  ldc1      $f20, 0x78($sp)
-/* 371A0 8005BDA0 03E00008 */  jr        $ra
-/* 371A4 8005BDA4 27BD00A8 */   addiu    $sp, $sp, 0xa8
diff --git a/ver/us/splat.yaml b/ver/us/splat.yaml
index a314346192..8830d33e9f 100644
--- a/ver/us/splat.yaml
+++ b/ver/us/splat.yaml
@@ -92,7 +92,7 @@ segments:
     - [0x341D0, c, 341d0]
     - [0x35080, c, effects]
     - [0x35AC0, c, world/world]
-    - [0x362A0, c, 362a0_len_2f70]
+    - [0x362A0, c, collision]
     - [0x39210, c, 39210_len_aa0]
     - [0x39CB0, c, os/39cb0_len_100]
     - [0x39DB0, c, os/nusys/nuSched]
diff --git a/ver/us/symbol_addrs.txt b/ver/us/symbol_addrs.txt
index d800c9762d..62e33569fa 100644
--- a/ver/us/symbol_addrs.txt
+++ b/ver/us/symbol_addrs.txt
@@ -824,13 +824,13 @@ get_current_map_header = 0x8005ABE8; // type:func rom:0x35FE8
 get_map_IDs_by_name = 0x8005ABF8; // type:func rom:0x35FF8
 load_asset_by_name = 0x8005ACE8; // type:func rom:0x360E8
 get_asset_offset = 0x8005ADD0; // type:func rom:0x361D0
-allocate_hit_tables = 0x8005AEA0; // type:func rom:0x362A0
+backup_map_collision_data = 0x8005AEA0; // type:func rom:0x362A0
 func_8005AF84 = 0x8005AF84; // type:func rom:0x36384
 func_8005AF8C = 0x8005AF8C; // type:func rom:0x3638C
 initialize_collision = 0x8005AF94; // type:func rom:0x36394
-load_hit_asset = 0x8005AFC0; // type:func rom:0x363C0
-load_collision = 0x8005B058; // type:func rom:0x36458
-load_stage_collision = 0x8005B1A0; // type:func rom:0x365A0
+load_map_hit_asset = 0x8005AFC0; // type:func rom:0x363C0
+restore_map_collision_data = 0x8005B058; // type:func rom:0x36458
+load_battle_hit_asset = 0x8005B1A0; // type:func rom:0x365A0
 load_hit_data = 0x8005B23C; // type:func rom:0x3663C
 parent_collider_to_model = 0x8005B780; // type:func rom:0x36B80
 _add_hit_vert_to_buffer = 0x8005B9A0; // type:func rom:0x36DA0
@@ -840,11 +840,11 @@ get_collider_type_by_id = 0x8005BDA8; // type:func rom:0x371A8
 get_flat_collider_normal = 0x8005BDD8; // type:func rom:0x371D8
 get_collider_center = 0x8005BE10; // type:func rom:0x37210
 test_ray_triangle_general = 0x8005BE84; // type:func rom:0x37284
-test_down_ray_triangle = 0x8005C49C; // type:func rom:0x3789C
-test_up_ray_triangle = 0x8005C7A4; // type:func rom:0x37BA4
+test_ray_triangle_down = 0x8005C49C; // type:func rom:0x3789C
+test_ray_triangle_horizontal = 0x8005C7A4; // type:func rom:0x37BA4
 test_ray_colliders = 0x8005CCD0; // type:func rom:0x380D0
 test_ray_zones = 0x8005D124; // type:func rom:0x38524
-test_up_ray_collider = 0x8005D2DC; // type:func rom:0x386DC
+test_ray_collider_horizontal = 0x8005D2DC; // type:func rom:0x386DC
 test_ray_entities = 0x8005D448; // type:func rom:0x38848
 func_8005DB00 = 0x8005DB00; // type:func rom:0x38F00
 func_8005DD54 = 0x8005DD54; // type:func rom:0x39154
@@ -1439,8 +1439,8 @@ D_8007F204 = 0x8007F204; // type:data rom:0x5A604
 gEffectTable = 0x8007F210; // type:data rom:0x5A610 size:0xCA8
 D_8007FEB8 = 0x8007FEB8; // type:data rom:0x5B2B8
 D_8008FF60 = 0x8008FF60; // type:data rom:0x6B360
-D_8008FF70 = 0x8008FF70; // type:data rom:0x6B370
-D_8008FFB8 = 0x8008FFB8; // type:data rom:0x6B3B8
+gEntityColliderFaces = 0x8008FF70; // type:data rom:0x6B370
+gEntityColliderNormals = 0x8008FFB8; // type:data rom:0x6B3B8
 mac_maps = 0x80090050; // type:data rom:0x6B450
 tik_maps = 0x80090150; // type:data rom:0x6B550
 kgr_maps = 0x80090410; // type:data rom:0x6B810
@@ -1924,21 +1924,21 @@ D_800A41E4 = 0x800A41E4; // type:data rom:0x7F5E4
 gMapConfig = 0x800A41E8; // type:data rom:0x7F5E8
 D_800A41EC = 0x800A41EC; // type:data rom:0x7F5EC
 check_input_jump = 0x800E6160; // type:func rom:0x7F610
-D_800A4230 = 0x800A4230; // type:data rom:0x7F630
-D_800A4234 = 0x800A4234; // type:data rom:0x7F634
-D_800A4238 = 0x800A4238; // type:data rom:0x7F638
-D_800A423C = 0x800A423C; // type:data rom:0x7F63C
-D_800A4240 = 0x800A4240; // type:data rom:0x7F640
-D_800A4244 = 0x800A4244; // type:data rom:0x7F644
-D_800A4248 = 0x800A4248; // type:data rom:0x7F648
-D_800A424C = 0x800A424C; // type:data rom:0x7F64C
-D_800A4250 = 0x800A4250; // type:data rom:0x7F650
-D_800A4254 = 0x800A4254; // type:data rom:0x7F654
-D_800A4258 = 0x800A4258; // type:data rom:0x7F658
-D_800A425C = 0x800A425C; // type:data rom:0x7F65C
-D_800A4260 = 0x800A4260; // type:data rom:0x7F660
-D_800A4264 = 0x800A4264; // type:data rom:0x7F664
-D_800A4268 = 0x800A4268; // type:data rom:0x7F668
+gCollisionRayStartX = 0x800A4230; // type:data rom:0x7F630
+gCollisionRayStartY = 0x800A4234; // type:data rom:0x7F634
+gCollisionRayStartZ = 0x800A4238; // type:data rom:0x7F638
+gCollisionRayDirX = 0x800A423C; // type:data rom:0x7F63C
+gCollisionRayDirY = 0x800A4240; // type:data rom:0x7F640
+gCollisionRayDirZ = 0x800A4244; // type:data rom:0x7F644
+gCollisionPointX = 0x800A4248; // type:data rom:0x7F648
+gCollisionPointY = 0x800A424C; // type:data rom:0x7F64C
+gCollisionPointZ = 0x800A4250; // type:data rom:0x7F650
+gCollisionRayLength = 0x800A4254; // type:data rom:0x7F654
+gCollisionNormalX = 0x800A4258; // type:data rom:0x7F658
+gCollisionNormalY = 0x800A425C; // type:data rom:0x7F65C
+gCollisionNormalZ = 0x800A4260; // type:data rom:0x7F660
+gCollisionDataBackup = 0x800A4264; // type:data rom:0x7F664
+gCollisionDataZoneBackup = 0x800A4268; // type:data rom:0x7F668
 D_800A426C = 0x800A426C; // type:data rom:0x7F66C
 D_800A4270 = 0x800A4270; // type:data rom:0x7F670
 check_input_spin = 0x800E6268; // type:func rom:0x7F718
@@ -2432,7 +2432,7 @@ clear_render_tasks_alt = 0x8011D8D0; // type:func rom:0xB3FD0
 queue_render_task = 0x8011D910; // type:func rom:0xB4010
 execute_render_tasks = 0x8011D9B8; // type:func rom:0xB40B8
 animator_copy_vertices_to_buffer = 0x8011DE80; // type:func rom:0xB4580
-D_800D91D0 = 0x800D91D0; // type:data rom:0xB45D0
+gZoneCollisionData = 0x800D91D0; // type:data rom:0xB45D0
 D_800D91D4 = 0x800D91D4; // type:data rom:0xB45D4
 D_800D91D8 = 0x800D91D8; // type:data rom:0xB45D8
 D_800D91DC = 0x800D91DC; // type:data rom:0xB45DC