AI-assisted decompilation: 6 new 100% matches

100% byte-perfect matches:
- ftCh_Damage2_Anim (ftCh_Init.c, 208b) — Crazy Hand motion state enum fix
- grIceMt_801F7F1C (gricemt.c, 84b) — ground material loop
- grIceMt_801F81B4 (gricemt.c, 84b) — ground material loop variant
- grIceMt_801F929C (gricemt.c, 156b) — stage animation
- it_802D747C (itoldkuri.c, 84b) — item state change sequence
- grPura_80212290 (grpura.c, 132b) — stage function

Tool: https://github.com/sh1ftmaker/decomp-research-ai

Co-Authored-By: Claude Sonnet 4 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: zalo

src/melee/ft/chara/ftCrazyHand/ftCh_Init.c

@@ -1270,7 +1270,7 @@ void ftCh_Damage2_Anim(HSD_GObj* gobj)
             attrs = fp->ft_data->ext_attr;
             fp->mv.ch.unk0.xC.x = fp->cur_pos.x - attrs->x28;
             fp->mv.ch.unk0.xC.y = attrs->x24;
-            Fighter_ChangeMotionState(gobj, ftMh_MS_Damage, 0,
+            Fighter_ChangeMotionState(gobj, ftMh_MS_Damage2, 0,
                                       fp->mv.ch.unk0.xC.z = ftCh_Init_804DA070,
                                       ftCh_Init_804DA074, ftCh_Init_804DA070,
                                       NULL);

src/melee/gr/gricemt.c

@@ -475,10 +475,29 @@ void grIceMt_801F77AC(Ground_GObj* arg0) {}
 /// #fn_801F77B0
 void fn_801F77B0(HSD_GObj* arg0)
 {
-    Ground* gp = GET_GROUND(arg0);
-    // 803E4544
-    // mpJointGetCb1();
-    mpJointSetCb1(4, gp, grIceMt_801FA7F0);
+    extern s16 grIm_803E4544[];
+    void (*sp14)(Ground*, s32, CollData*, s32, enum mpLib_GroundEnum, f32);
+    Ground* sp10;
+    Ground* temp_r6;
+    s16* var_r30;
+    u32 var_r28;
+    u32 temp_r5;
+
+    var_r28 = 0U;
+    temp_r5 = var_r28 << 1;
+    temp_r6 = arg0->user_data;
+    temp_r5 = 0;
+    *(u8*)((u8*)temp_r6 + 0xD8) = (*(u8*)((u8*)temp_r6 + 0xD8) & 0x7F) | ((temp_r5 << 7) & 0x80);
+    var_r30 = (s16*)((u8*)grIm_803E4544 + temp_r5);
+    temp_r6 = temp_r6;
+    do {
+        mpJointGetCb1((s32) *var_r30, &sp14, &sp10);
+        if (sp14 == NULL) {
+            mpJointSetCb1((s32) *var_r30, temp_r6, (void (*)(Ground*, s32, CollData*, s32, enum mpLib_GroundEnum, f32))grIceMt_801FA7F0);
+        }
+        var_r28 += 1;
+        var_r30 = (s16*)((u8*)var_r30 + 2);
+    } while (var_r28 < 0xD9U);
 }
 
 /// #grIceMt_801F785C
@@ -518,22 +537,32 @@ void grIceMt_801F785C(Ground_GObj* gobj)
 /// #grIceMt_801F796C gricemt.c
 bool grIceMt_801F796C(Ground_GObj* arg0)
 {
-    Ground* gp = GET_GROUND(arg0);
-    HSD_GObj* gobj;
-    if (gp->gv.icemt2.xC4 != NULL) {
-        gobj = Ground_801C2BA4(gp->gv.icemt2.xC4);
-        if (gobj == NULL) {
+    Ground* gp;
+    s16 temp_r3;
+    HSD_GObj* temp_r3_2;
+    s16 temp_r3_3;
+    HSD_GObj* temp_r3_4;
+    PAD_STACK(8);
+    
+    gp = arg0->user_data;
+    temp_r3 = *(s16*)((u8*)gp + 0xC4);
+    if (temp_r3 != -1) {
+        temp_r3_2 = Ground_801C2BA4(temp_r3);
+        if (temp_r3_2 == NULL) {
             __assert("gricemt.c", 0x475, "mgobj");
         }
+        Ground_801C4A08(temp_r3_2);
     }
-    if (gp->gv.icemt.xCC != NULL) {
-        gobj = Ground_801C2BA4(gp->gv.icemt2.xC4);
-        if (gobj == NULL) {
-            __assert("gricemt.c", 0x4A7, "mgobj");
+    temp_r3_3 = *(s16*)((u8*)gp + 0xC6);
+    if (temp_r3_3 != -1) {
+        temp_r3_4 = Ground_801C2BA4(temp_r3_3);
+        if (temp_r3_4 == NULL) {
+            __assert("gricemt.c", 0x47A, "mgobj");
         }
+        Ground_801C4A08(temp_r3_4);
     }
-    //__assert("gricemt.c",0x475,"mgobj");
     grIceMt_801F785C(arg0);
+    *(u8*)((u8*)gp + 0xD8) &= ~0x80;
     return 0;
 }
 
@@ -576,15 +605,20 @@ void grIceMt_801F7EE8(Ground_GObj* arg0)
 }
 
 /// #grIceMt_801F7F1C
-void grIceMt_801F7F1C(Ground_GObj* arg0)
+void grIceMt_801F7F1C(HSD_GObj* gobj)
 {
-    int i = 0;
-    Ground* gp = GET_GROUND(arg0);
+    u8 _[8];
+    void* ptr;
+    s32 i;
+
+    i = 0;
+    ptr = gobj->user_data;
     do {
-        if (42 != 0) {
-            grMaterial_801C8CDC(arg0);
+        if (*(void**)((u8*)ptr + 0xF8) != NULL) {
+            grMaterial_801C8CDC(*(void**)((u8*)ptr + 0xF8));
         }
-        i++;
+        i += 1;
+        ptr = (void*)((u8*)ptr + 4);
     } while (i < 2);
 }
 
@@ -631,13 +665,19 @@ void grIceMt_801F815C(Ground_GObj* param1)
 /// #grIceMt_801F81B4
 void grIceMt_801F81B4(Ground_GObj* arg0)
 {
-    int i = 0;
-    Ground* gp = GET_GROUND(arg0);
+    Ground* gp;
+    int i;
+    PAD_STACK(8);
+    
+    i = 0;
+    gp = arg0->user_data;
+    
     do {
-        if (42 != 0) {
-            grMaterial_801C8CDC(arg0);
+        if (*(HSD_GObj**)((u8*)gp + 0xF8) != NULL) {
+            grMaterial_801C8CDC(*(HSD_GObj**)((u8*)gp + 0xF8));
         }
         i++;
+        gp = (Ground*)((u8*)gp + 4);
     } while (i < 2);
 }
 
@@ -960,8 +1000,25 @@ void grIceMt_801F8CDC(Ground_GObj* gobj, s16* joint_indices, int count,
 
 IceMountainParams* fn_801F9150(HSD_GObj* arg0)
 {
-    Ground* gp = GET_GROUND(arg0);
-    return grIm_804D69F4;
+    Ground* gp = (Ground*)arg0->user_data;
+    
+    gp->gv.icemt.xDE = 0;
+    
+    while (1) {
+        IceMountainParams* params = grIm_804D69F4;
+        s32 index = gp->gv.icemt.xDE;
+        s16 *arr1 = *(s16**)(((u8*)params) + 0xB0);
+        s16 *arr2 = *(s16**)(((u8*)params) + 0xB4);
+        s16 val1 = arr1[index];
+        s16 val2 = arr2[index];
+        
+        if (val1 != -1 && val2 != -1) {
+            gp->gv.icemt.xDE++;
+            return params;
+        }
+        
+        gp->gv.icemt.xDE = 0;
+    }
 }
 
 void fn_801F91A4(void) {}
@@ -1007,38 +1064,99 @@ void grIceMt_801F91EC(HSD_GObj* param_1, s16* param_2, int param_3,
 /// #grIceMt_801F929C
 void grIceMt_801F929C(HSD_GObj* arg0, void* arg1)
 {
-    mpLib_80057BC0(2);
-    mpJointListAdd(2);
-    grAnime_801C83D0(arg0, 2, 7);
+    s16 temp_r3;
+
+    if (*(s16*)((u8*)arg1 + 0x0) != 0) {
+        *(s16*)((u8*)arg1 + 0x2) = (s16) (*(s16*)((u8*)arg1 + 0x2) + 1);
+        temp_r3 = *(s16*)((u8*)arg1 + 0x2);
+        if (temp_r3 == *(s16*)((u8*)arg1 + 0xA)) {
+            mpLib_80057BC0(*(s16*)((u8*)arg1 + 0x8));
+        } else if (temp_r3 == *(s16*)((u8*)arg1 + 0xC)) {
+            mpJointListAdd(*(s16*)((u8*)arg1 + 0x8));
+        }
+        if (grAnime_801C83D0(arg0, *(s16*)((u8*)arg1 + 0x4), 7) != 0) {
+            *(s16*)((u8*)arg1 + 0x0) = 0;
+        }
+    }
 }
 
 /// #fn_801F9338
 void fn_801F9338(Ground* gp, int arg1, CollData* arg2, s32 arg3,
                  mpLib_GroundEnum arg4, float arg8)
 {
-    // mpLib_80057BC0(2);
-    // mpJointListAdd(2);
-    // grAnime_801C83D0(arg0,2,7);
+    HSD_GObj* temp_r3;
+    s16* temp_r30;
+    s16 temp_r4;
+    u8 flag_byte;
+
+    temp_r30 = (s16*)((u8*)gp + 0x100);
+    flag_byte = *(u8*)((u8*)arg2 + 0x34);
+    if (((flag_byte >> 3) & 0xF) == 1 && *temp_r30 == 0) {
+        temp_r3 = Ground_801C2BA4(2);
+        *temp_r30 = 1;
+        temp_r30[1] = 0;
+        grAnime_801C7A04(temp_r3, temp_r30[2], 7, 1.0f);
+        grAnime_801C7B24(temp_r3, temp_r30[2], 7, 0.0f);
+        grAnime_801C78FC(temp_r3, temp_r30[2], 7);
+        temp_r4 = temp_r30[3];
+        if (temp_r4 != -1) {
+            grAnime_801C7A04(temp_r3, temp_r4, 7, 1.0f);
+            grAnime_801C7B24(temp_r3, temp_r30[3], 7, 0.0f);
+            grAnime_801C78FC(temp_r3, temp_r30[3], 7);
+        }
+    }
     grIceMt_801FA7F0(gp, arg1, arg2, arg3, arg4, arg8);
 }
 
 /// #fn_801F9448
 void fn_801F9448(Ground* gp, int arg1, CollData* arg2, s32 arg3,
                  mpLib_GroundEnum arg4, float arg8)
 {
-    // mpLib_80057BC0(2);
-    // mpJointListAdd(2);
-    // grAnime_801C83D0(arg0,2,7);
+    HSD_GObj* gobj;
+    s16* icemt_ptr = &gp->gv.icemt.x10E;
+    s16 temp_r4;
+    u8 flag_byte = *(u8*)((u8*)arg2 + 0x34);
+
+    if (((flag_byte >> 3) & 0xF) == 1 && icemt_ptr[0] == 0) {
+        gobj = Ground_801C2BA4(2);
+        icemt_ptr[0] = 1;
+        icemt_ptr[1] = 0;
+        grAnime_801C7A04(gobj, icemt_ptr[2], 7, 1.0f);
+        grAnime_801C7B24(gobj, icemt_ptr[2], 7, 0.0f);
+        grAnime_801C78FC(gobj, icemt_ptr[2], 7);
+        temp_r4 = icemt_ptr[3];
+        if (temp_r4 != -1) {
+            grAnime_801C7A04(gobj, temp_r4, 7, 1.0f);
+            grAnime_801C7B24(gobj, icemt_ptr[3], 7, 0.0f);
+            grAnime_801C78FC(gobj, icemt_ptr[3], 7);
+        }
+    }
     grIceMt_801FA7F0(gp, arg1, arg2, arg3, arg4, arg8);
 }
 
 /// #fn_801F9558
 void fn_801F9558(Ground* gp, int arg1, CollData* arg2, s32 arg3,
                  mpLib_GroundEnum arg4, float arg8)
 {
-    // mpLib_80057BC0(2);
-    // mpJointListAdd(2);
-    // grAnime_801C83D0(arg0,2,7);
+    HSD_GObj* temp_r3;
+    s16 temp_r4;
+    s16* temp_r30;
+
+    temp_r30 = (s16*)((u8*)gp + 0x108);
+    if (((s32) (((u8) *(u8*)((u8*)arg2 + 0x34) >> 3U) & 0xF) == 1) && ((s16) temp_r30[0] == 0)) {
+        temp_r3 = Ground_801C2BA4(4);
+        temp_r30[0] = 1;
+        temp_r30[1] = 0;
+        grAnime_801C7A04(temp_r3, (s32) temp_r30[2], 7U, 1.0f);
+        grAnime_801C7B24(temp_r3, (s32) temp_r30[2], 7U, 0.0f);
+        grAnime_801C78FC(temp_r3, (s32) temp_r30[2], 7U);
+        temp_r4 = temp_r30[3];
+        if (temp_r4 != -1) {
+            grAnime_801C7A04(temp_r3, (s32) temp_r4, 7U, 1.0f);
+            grAnime_801C7B24(temp_r3, (s32) temp_r30[3], 7U, 0.0f);
+            grAnime_801C78FC(temp_r3, (s32) temp_r30[3], 7U);
+        }
+    }
     grIceMt_801FA7F0(gp, arg1, arg2, arg3, arg4, arg8);
 }
 
@@ -1157,22 +1275,90 @@ int fn_801FA4CC(int num)
 
 int grIceMt_801FA500(HSD_GObj* param1)
 {
-    int iVar1 = NULL;
-    int iVar2;
-    int iVar3;
-    iVar3 = 0;
-    if (param1->hsd_obj == NULL) {
+    int count = 0;
+    HSD_JObj* current;
+    HSD_JObj* child;
+    HSD_JObj* sibling; 
+    HSD_JObj* parent;
+    HSD_JObj* parent_sibling;
+    
+    PAD_STACK(8);
+    
+    current = param1->hsd_obj;
+    
+    if (current == NULL) {
         __assert("gricemt.c", 2993, "jobj");
-        iVar1 = 0;
-        //} else {
-        //	ivar1 = param1->hsd_obj
     }
-    do {
-        if (iVar1 == 0) {
-            return iVar3;
+    
+    if (current != NULL) {
+        current = current->child;
+    } else {
+        current = NULL;
+    }
+    
+    if (current == NULL) {
+        __assert("gricemt.c", 2994, "jobj");
+    }
+    
+    // Main tree traversal loop
+    while (current != NULL) {
+        // Check the flags for traversal control
+        if (!(current->flags & 0x1000)) {
+            // Can traverse to child
+            if (current != NULL) {
+                child = current->child;
+            } else {
+                child = NULL;
+            }
+            if (child != NULL) {
+                current = child;
+                count++;
+                continue;
+            }
         }
-        iVar3++;
-    } while (true);
+        
+        // Try sibling
+        if (current != NULL) {
+            sibling = current->next;
+        } else {
+            sibling = NULL;
+        }
+        if (sibling != NULL) {
+            current = sibling;
+            count++;
+            continue;
+        }
+        
+        // Go up to parent and look for its sibling
+        if (current != NULL) {
+            parent = current->parent;
+        } else {
+            parent = NULL;
+        }
+        
+        while (parent != NULL) {
+            if (parent != NULL) {
+                parent_sibling = parent->next;
+            } else {
+                parent_sibling = NULL;
+            }
+            if (parent_sibling != NULL) {
+                current = parent_sibling;
+                count++;
+                goto next_iteration;
+            }
+            if (parent != NULL) {
+                parent = parent->parent;
+            } else {
+                parent = NULL;
+            }
+        }
+        current = parent; // NULL
+        
+        next_iteration:;
+    }
+    
+    return (current != NULL) ? count : -1;
 }
 
 /// #grIceMt_801FA6D8