diff --git a/include/entity.h b/include/entity.h
index 1b872aeb29..a530ccc9b1 100644
--- a/include/entity.h
+++ b/include/entity.h
@@ -1613,7 +1613,7 @@ typedef struct {
     s16 unk88;
     s16 unk8A;
     struct Entity* parent;
-    s16 unk90;
+    s16 colorIntensity;
     s16 unk92;
     s32 unk94;
     s16 unk98;
diff --git a/src/boss/bo4/unk_46E7C.c b/src/boss/bo4/unk_46E7C.c
index 91b1ccc898..b016db1b9e 100644
--- a/src/boss/bo4/unk_46E7C.c
+++ b/src/boss/bo4/unk_46E7C.c
@@ -2509,35 +2509,35 @@ extern u8** bat_form_sprites[];
 // player turns white for some sort of status effect
 void EntityDopplegangerBlinkWhite(Entity* self) {
     Primitive* prim;
-    u8 var_s7;
-    u8 var_s6;
-    u8 sp7f;
-    u8 sp7e;
-    s16 sp7c;
-    s16 sp7a;
+    u8 xMargin;
+    u8 yMargin;
+    u8 wSprite;
+    u8 hSprite;
+    s16 xPivot;
+    s16 yPivot;
     s16 xOffset;
     s16 yOffset;
     s16 sp78;
     s16 sp76;
     s16 sp74;
-    s16 sp72;
-    s16 posX;
-    s16 posY;
+    s16 dopSpriteIndex;
+    s16 posX; // TODO: selfX
+    s16 posY; // TODO: selfY
     s16* sp5c;
-    u8* sp58;
+    u8* plSprite;
     s32 i;
     s32 sp54;
     s32 sp50;
 
-    s16 maskedParams;
+    s16 upperParams;
     s16 angle;
-    s16 sp6e;
-    s16* sp4c;
-    s16 sp6c;
-    s16 sp6a;
-    s16 sp68;
-    s16 sp66;
-    s16 sp64;
+    s16 angleRedIndex;
+    s16* dataPtr;
+    s16 angleGreenIndex;
+    s16 angleBlueIndex;
+    s16 redDivide;
+    s16 blueDivide;
+    s16 greenDivide;
     s16 sp62;
     s16 sp60;
 
@@ -2545,17 +2545,17 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
     Entity* sp3C;
     s32 sp38;
 
-    maskedParams = (self->params & 0x7F00) >> 8;
+    upperParams = (self->params & 0x7F00) >> 8;
 
-    if (((maskedParams & 0x3F) != 0x1D) &&
+    if (((upperParams & 0x3F) != 0x1D) &&
         (g_Dop.status & PLAYER_STATUS_MIST_FORM)) {
         D_us_80181B70 = 0;
         DestroyEntity(self);
         return;
     }
 
-    if ((D_us_80181B70) && maskedParams != 0x20 && maskedParams != 0x21 &&
-        ((maskedParams & 0x3F) != 0x1D)) {
+    if ((D_us_80181B70) && upperParams != 0x20 && upperParams != 0x21 &&
+        ((upperParams & 0x3F) != 0x1D)) {
         DestroyEntity(self);
         return;
     }
@@ -2574,27 +2574,27 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
         return;
     }
 
-    sp72 = *sp5c++;
-    sp72 &= 0x7FFF;
+    dopSpriteIndex = *sp5c++;
+    dopSpriteIndex &= 0x7FFF;
 
     posX = self->posX.i.hi;
     posY = self->posY.i.hi;
 
     if (DOPPLEGANGER.animSet == (s16)ANIMSET_OVL(1)) {
-        sp58 = doppleganger_sprites[sp72];
+        plSprite = doppleganger_sprites[dopSpriteIndex];
     }
     if (DOPPLEGANGER.animSet == (s16)ANIMSET_OVL(2)) {
-        sp58 = bat_form_sprites[sp72];
+        plSprite = bat_form_sprites[dopSpriteIndex];
     }
 
-    var_s7 = 4;
-    var_s6 = 1;
-    sp7f = var_s7 + sp58[0];
-    sp7e = var_s6 + sp58[1];
-    xOffset = sp7f - var_s7;
-    yOffset = sp7e - var_s6;
-    sp7c = sp5c[0] + sp58[2];
-    sp7a = sp5c[1] + sp58[3];
+    xMargin = 4;
+    yMargin = 1;
+    wSprite = xMargin + plSprite[0];
+    hSprite = yMargin + plSprite[1];
+    xOffset = wSprite - xMargin; // TODO: or width
+    yOffset = hSprite - yMargin; // TODO: or height
+    xPivot = sp5c[0] + plSprite[2];
+    yPivot = sp5c[1] + plSprite[3];
 
     self->rotate = DOPPLEGANGER.rotate;
     self->drawFlags = DOPPLEGANGER.drawFlags;
@@ -2603,7 +2603,7 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
     self->rotPivotY = DOPPLEGANGER.rotPivotY;
     self->rotPivotX = DOPPLEGANGER.rotPivotX;
 
-    sp4c = D_us_801818A0[maskedParams & 0x3F];
+    dataPtr = D_us_801818A0[upperParams & 0x3F];
     switch (self->step) {
     case 0:
         if (func_8011BD48(self)) {
@@ -2620,43 +2620,43 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
         for (i = 0; i < 8; i++) {
             D_us_80181860[i] = i << 9;
             prim->tpage = 0x10;
-            prim->clut = sp4c[3];
+            prim->clut = dataPtr[3];
             prim->r0 = prim->b0 = prim->g0 = prim->r1 = prim->b1 = prim->g1 =
                 prim->r2 = prim->b2 = prim->g2 = prim->r3 = prim->b3 =
                     prim->g3 = 0x80;
             prim->priority = DOPPLEGANGER.zPriority + 2;
 
-            prim->drawMode = sp4c[8] + DRAW_COLORS + DRAW_UNK02;
+            prim->drawMode = dataPtr[8] + DRAW_COLORS + DRAW_UNK02;
             prim = prim->next;
         }
-        self->ext.playerBlink.unk8A = sp4c[9];
-        self->ext.playerBlink.unk90 = 0;
+        self->ext.playerBlink.unk8A = dataPtr[9];
+        self->ext.playerBlink.colorIntensity = 0;
         self->ext.playerBlink.unk98 = 0;
         self->ext.playerBlink.unk9A = 0x100;
         self->step++;
-        if (maskedParams == 0x20) {
+        if (upperParams == 0x20) {
             self->step = 8;
         }
-        if (maskedParams == 0x21) {
+        if (upperParams == 0x21) {
             self->step = 0xA;
         }
         break;
     case 1:
-        if (sp4c[7] == 0x7008) {
-            self->ext.playerBlink.unk90 += 0x50;
+        if (dataPtr[7] == 0x7008) {
+            self->ext.playerBlink.colorIntensity += 0x50;
         } else {
-            self->ext.playerBlink.unk90 += 0xA;
+            self->ext.playerBlink.colorIntensity += 0xA;
         }
-        if (self->ext.playerBlink.unk90 > 0x100) {
-            self->ext.playerBlink.unk90 = 0x100;
-            self->ext.playerBlink.unk80 = sp4c[7];
+        if (self->ext.playerBlink.colorIntensity > 0x100) {
+            self->ext.playerBlink.colorIntensity = 0x100;
+            self->ext.playerBlink.unk80 = dataPtr[7];
             self->step++;
         }
         break;
     case 2:
-        if (sp4c[7] >= 0x7000) {
+        if (dataPtr[7] >= 0x7000) {
             self->ext.playerBlink.unk80 = 8;
-            switch ((u32)sp4c[7]) {
+            switch ((u32)dataPtr[7]) {
             case 0x7000:
                 if (g_Dop.timers[ALU_T_CURSE] == 0) {
                     self->step++;
@@ -2692,14 +2692,14 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
         }
         break;
     case 3:
-        self->ext.playerBlink.unk90 -= 10;
-        if (self->ext.playerBlink.unk90 < 0) {
+        self->ext.playerBlink.colorIntensity -= 10;
+        if (self->ext.playerBlink.colorIntensity < 0) {
             DestroyEntity(self);
             return;
         }
         break;
     case 8:
-        D_us_80181B70 = 1;
+        D_us_80181B70 = 1; // TODO: g_Dop.unk6C = 1;
         self->ext.playerBlink.unk98 += 8;
         self->ext.playerBlink.unk9C += 256;
         if (self->ext.playerBlink.unk98 > 128) {
@@ -2721,12 +2721,12 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
                 prim->clut = 0x15F;
                 prim = prim->next;
             }
-            D_us_80181B70 = 0;
+            D_us_80181B70 = 0; // TODO: g_Dop.unk6C = 0;
             return;
         }
         break;
     case 10:
-        D_us_80181B70 = 1;
+        D_us_80181B70 = 1; // TODO: g_Dop.unk6C = 1;
         self->ext.playerBlink.unk98 += 8;
         self->ext.playerBlink.unk9C += 0x100;
         if (self->ext.playerBlink.unk98 > 0x80) {
@@ -2742,20 +2742,20 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
     sp76 = self->ext.playerBlink.unk98;
     sp54 = 3;
     sp50 = 6;
-    if (sp4c[7] == 0x700A) {
+    if (dataPtr[7] == 0x700A) {
         sp50 = 0;
         sp54 = 0;
     }
     self->ext.playerBlink.unk82 += self->ext.playerBlink.unk8A;
     if (self->facingLeft) {
-        posX = posX - sp7c;
+        posX = posX - xPivot;
     } else {
-        posX = posX + sp7c;
+        posX = posX + xPivot;
     }
-    posY = posY + sp7a;
+    posY = posY + yPivot;
     prim = &g_PrimBuf[self->primIndex];
     for (i = 0; i < 8; i++) {
-        if (maskedParams & 0x40) {
+        if (upperParams & 0x40) {
             switch (i) {
             case 0:
                 if (self->facingLeft) {
@@ -2764,12 +2764,12 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
                     prim->x1 = posX + xOffset / 2;
                 }
                 prim->x0 = posX;
-                prim->u0 = var_s7;
-                prim->u1 = var_s7 + xOffset / 2;
+                prim->u0 = xMargin;
+                prim->u1 = xMargin + xOffset / 2;
                 prim->y1 = posY;
                 prim->y0 = posY;
-                prim->v1 = var_s6;
-                prim->v0 = var_s6;
+                prim->v1 = yMargin;
+                prim->v0 = yMargin;
                 break;
             case 1:
                 if (self->facingLeft) {
@@ -2779,10 +2779,10 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
                     prim->x0 = posX + xOffset / 2;
                     prim->x1 = posX + xOffset;
                 }
-                prim->u0 = var_s7 + xOffset / 2;
-                prim->u1 = var_s7 + xOffset;
+                prim->u0 = xMargin + xOffset / 2;
+                prim->u1 = xMargin + xOffset;
                 prim->y0 = prim->y1 = posY;
-                prim->v0 = prim->v1 = var_s6;
+                prim->v0 = prim->v1 = yMargin;
                 break;
             case 2:
                 if (self->facingLeft) {
@@ -2790,11 +2790,11 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
                 } else {
                     prim->x0 = prim->x1 = posX + xOffset;
                 }
-                prim->u0 = prim->u1 = var_s7 + xOffset;
+                prim->u0 = prim->u1 = xMargin + xOffset;
                 prim->y0 = posY;
                 prim->y1 = posY + yOffset / 2;
-                prim->v0 = var_s6;
-                prim->v1 = var_s6 + yOffset / 2;
+                prim->v0 = yMargin;
+                prim->v1 = yMargin + yOffset / 2;
                 break;
             case 3:
                 if (self->facingLeft) {
@@ -2803,11 +2803,11 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
                     prim->x0 = prim->x1 = posX + xOffset;
                 }
 
-                prim->u0 = prim->u1 = var_s7 + xOffset;
+                prim->u0 = prim->u1 = xMargin + xOffset;
                 prim->y0 = posY + yOffset / 2;
                 prim->y1 = posY + yOffset;
-                prim->v0 = var_s6 + yOffset / 2;
-                prim->v1 = var_s6 + yOffset;
+                prim->v0 = yMargin + yOffset / 2;
+                prim->v1 = yMargin + yOffset;
                 break;
             case 4:
                 if (self->facingLeft) {
@@ -2817,10 +2817,10 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
                     prim->x0 = posX + xOffset;
                     prim->x1 = posX + xOffset / 2;
                 }
-                prim->u0 = var_s7 + xOffset;
-                prim->u1 = var_s7 + xOffset / 2;
+                prim->u0 = xMargin + xOffset;
+                prim->u1 = xMargin + xOffset / 2;
                 prim->y0 = prim->y1 = posY + yOffset;
-                prim->v0 = prim->v1 = var_s6 + yOffset;
+                prim->v0 = prim->v1 = yMargin + yOffset;
                 break;
             case 5:
                 if (self->facingLeft) {
@@ -2829,31 +2829,31 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
                     prim->x0 = posX + xOffset / 2;
                 }
                 prim->x1 = posX;
-                prim->u0 = var_s7 + xOffset / 2;
-                prim->u1 = var_s7;
+                prim->u0 = xMargin + xOffset / 2;
+                prim->u1 = xMargin;
                 prim->y0 = prim->y1 = posY + yOffset;
-                prim->v0 = prim->v1 = var_s6 + yOffset;
+                prim->v0 = prim->v1 = yMargin + yOffset;
 
                 break;
             case 6:
                 prim->x1 = posX;
                 prim->x0 = posX;
-                prim->u1 = var_s7;
-                prim->u0 = var_s7;
+                prim->u1 = xMargin;
+                prim->u0 = xMargin;
                 prim->y0 = posY + yOffset;
                 prim->y1 = posY + yOffset / 2;
-                prim->v0 = var_s6 + yOffset;
-                prim->v1 = var_s6 + yOffset / 2;
+                prim->v0 = yMargin + yOffset;
+                prim->v1 = yMargin + yOffset / 2;
                 break;
             case 7:
                 prim->x1 = posX;
                 prim->x0 = posX;
-                prim->u1 = var_s7;
-                prim->u0 = var_s7;
+                prim->u1 = xMargin;
+                prim->u0 = xMargin;
                 prim->y0 = posY + yOffset / 2;
                 prim->y1 = posY;
-                prim->v0 = var_s6 + yOffset / 2;
-                prim->v1 = var_s6;
+                prim->v0 = yMargin + yOffset / 2;
+                prim->v1 = yMargin;
                 break;
             }
             if (self->facingLeft) {
@@ -2868,8 +2868,8 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
             prim->y2 = prim->y3 =
                 (posY + yOffset / 2) -
                 ((rsin(self->ext.playerBlink.unk82) >> 4) * sp50 >> 8);
-            prim->u2 = prim->u3 = var_s7 + xOffset / 2;
-            prim->v2 = prim->v3 = var_s6 + yOffset / 2;
+            prim->u2 = prim->u3 = xMargin + xOffset / 2;
+            prim->v2 = prim->v3 = yMargin + yOffset / 2;
         } else {
             if (self->facingLeft) {
                 prim->x0 = prim->x2 = (posX - xOffset) + 1;
@@ -2878,7 +2878,7 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
                 prim->x0 = prim->x2 = posX;
                 prim->x1 = prim->x3 = posX + xOffset;
             }
-            if (maskedParams == 0x20 || maskedParams == 0x21) {
+            if (upperParams == 0x20 || upperParams == 0x21) {
                 sp74 = (rsin(sp78) >> 7) * sp76 / 256;
                 prim->x0 += sp74;
                 prim->x1 += sp74;
@@ -2890,55 +2890,55 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
             prim->y0 = prim->y1 = posY + yOffset * i / 8;
             prim->y2 = prim->y3 = posY + yOffset * (i + 1) / 8;
             if (self->facingLeft) {
-                prim->u0 = prim->u2 = sp7f - 1;
-                prim->u1 = prim->u3 = var_s7 - 1;
+                prim->u0 = prim->u2 = wSprite - 1;
+                prim->u1 = prim->u3 = xMargin - 1;
             } else {
-                prim->u0 = prim->u2 = var_s7;
-                prim->u1 = prim->u3 = sp7f;
+                prim->u0 = prim->u2 = xMargin;
+                prim->u1 = prim->u3 = wSprite;
             }
-            prim->v0 = prim->v1 = var_s6 + yOffset * i / 8;
-            prim->v2 = prim->v3 = var_s6 + yOffset * (i + 1) / 8;
+            prim->v0 = prim->v1 = yMargin + yOffset * i / 8;
+            prim->v2 = prim->v3 = yMargin + yOffset * (i + 1) / 8;
         }
 
         g_api.func_800EB758(self->posX.i.hi, self->posY.i.hi, self,
                             self->drawFlags, (POLY_GT4*)prim, self->facingLeft);
 
-        if (maskedParams != 0x20 && maskedParams != 0x21) {
-            sp6e = sp4c[0];
-            sp6c = sp4c[2];
-            sp6a = sp4c[1];
-            sp68 = sp4c[4];
-            sp64 = sp4c[6];
-            sp66 = sp4c[5];
+        if (upperParams != 0x20 && upperParams != 0x21) {
+            angleRedIndex = dataPtr[0];
+            angleGreenIndex = dataPtr[2];
+            angleBlueIndex = dataPtr[1];
+            redDivide = dataPtr[4];
+            greenDivide = dataPtr[6];
+            blueDivide = dataPtr[5];
             // clang-format off
-            if (maskedParams & 0x40) {
-                angle = D_us_80181860[(i + sp6e) % 8];
-                prim->r0 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp68);
-                angle = D_us_80181860[(i + sp6c) % 8];
-                prim->g0 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp64);
-                angle = D_us_80181860[(i + sp6a) % 8];
-                prim->b0 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp66);
-                angle = D_us_80181860[(i + sp6e + 1) % 8];
-                prim->r1 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp68);
-                angle = D_us_80181860[(i + sp6c + 1) % 8];
-                prim->g1 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp64);
-                angle = D_us_80181860[(i + sp6a + 1) % 8];
-                prim->b1 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp66);
+            if (upperParams & 0x40) {
+                angle = D_us_80181860[(i + angleRedIndex) % 8];
+                prim->r0 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.colorIntensity / redDivide);
+                angle = D_us_80181860[(i + angleGreenIndex) % 8];
+                prim->g0 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.colorIntensity / greenDivide);
+                angle = D_us_80181860[(i + angleBlueIndex) % 8];
+                prim->b0 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.colorIntensity / blueDivide);
+                angle = D_us_80181860[(i + angleRedIndex + 1) % 8];
+                prim->r1 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.colorIntensity / redDivide);
+                angle = D_us_80181860[(i + angleGreenIndex + 1) % 8];
+                prim->g1 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.colorIntensity / greenDivide);
+                angle = D_us_80181860[(i + angleBlueIndex + 1) % 8];
+                prim->b1 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.colorIntensity / blueDivide);
                 prim->r2 = prim->g2 = prim->b2 = prim->r3 = prim->g3 = prim->b3 = 0;
                 D_us_80181860[i] += self->ext.playerBlink.unk8A;
             } else {
-                angle = D_us_80181860[(i + sp6e) % 8];
-                prim->r0 = prim->r1 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp68);
-                angle = D_us_80181860[(i + sp6c) % 8];
-                prim->g0 = prim->g1 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp64);
-                angle = D_us_80181860[(i + sp6a) % 8];
-                prim->b0 = prim->b1 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp66);
-                angle = D_us_80181860[(i + sp6e + 1) % 8];
-                prim->r2 = prim->r3 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp68);
-                angle = D_us_80181860[(i + sp6c + 1) % 8];
-                prim->g2 = prim->g3 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp64);
-                angle = D_us_80181860[(i + sp6a + 1) % 8];
-                prim->b2 = prim->b3 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp66);
+                angle = D_us_80181860[(i + angleRedIndex) % 8];
+                prim->r0 = prim->r1 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.colorIntensity / redDivide);
+                angle = D_us_80181860[(i + angleGreenIndex) % 8];
+                prim->g0 = prim->g1 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.colorIntensity / greenDivide);
+                angle = D_us_80181860[(i + angleBlueIndex) % 8];
+                prim->b0 = prim->b1 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.colorIntensity / blueDivide);
+                angle = D_us_80181860[(i + angleRedIndex + 1) % 8];
+                prim->r2 = prim->r3 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.colorIntensity / redDivide);
+                angle = D_us_80181860[(i + angleGreenIndex + 1) % 8];
+                prim->g2 = prim->g3 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.colorIntensity / greenDivide);
+                angle = D_us_80181860[(i + angleBlueIndex + 1) % 8];
+                prim->b2 = prim->b3 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.colorIntensity / blueDivide);
                 D_us_80181860[i] += self->ext.playerBlink.unk8A;
             }
         }
@@ -2946,7 +2946,8 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
         prim = prim->next;
     }
     func_us_801C5354(1, 1);
-    if (((maskedParams & 0x3F) == 0) || ((maskedParams & 0x3F) == 7)) {
+    if (((upperParams & 0x3F) == 0) || ((upperParams & 0x3F) == 7)) {
+        // set invincibility frames
         OVL_EXPORT(func_us_801C5430)(1, 0xA);
     }
 }
diff --git a/src/boss/rbo5/unk_4648C.c b/src/boss/rbo5/unk_4648C.c
index ea88d80d00..93586367d5 100644
--- a/src/boss/rbo5/unk_4648C.c
+++ b/src/boss/rbo5/unk_4648C.c
@@ -1993,35 +1993,35 @@ extern u8** g_PlOvlDopBatSpritesheet[1];
 // player turns white for some sort of status effect
 void EntityDopplegangerBlinkWhite(Entity* self) {
     Primitive* prim;
-    u8 var_s7;
-    u8 var_s6;
-    u8 sp7f;
-    u8 sp7e;
-    s16 sp7c;
-    s16 sp7a;
+    u8 xMargin;
+    u8 yMargin;
+    u8 wSprite;
+    u8 hSprite;
+    s16 xPivot;
+    s16 yPivot;
     s16 xOffset;
     s16 yOffset;
     s16 sp78;
     s16 sp76;
     s16 sp74;
-    s16 sp72;
-    s16 posX;
-    s16 posY;
+    s16 dopSpriteIndex;
+    s16 posX; // TODO: selfX
+    s16 posY; // TODO: selfY
     s16* sp5c;
-    u8* sp58;
+    u8* plSprite;
     s32 i;
     s32 sp54;
     s32 sp50;
 
-    s16 maskedParams;
+    s16 upperParams;
     s16 angle;
-    s16 sp6e;
-    s16* sp4c;
-    s16 sp6c;
-    s16 sp6a;
-    s16 sp68;
-    s16 sp66;
-    s16 sp64;
+    s16 angleRedIndex;
+    s16* dataPtr;
+    s16 angleGreenIndex;
+    s16 angleBlueIndex;
+    s16 redDivide;
+    s16 blueDivide;
+    s16 greenDivide;
     s16 sp62;
     s16 sp60;
 
@@ -2029,17 +2029,17 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
     Entity* sp3C;
     s32 sp38;
 
-    maskedParams = (self->params & 0x7F00) >> 8;
+    upperParams = (self->params & 0x7F00) >> 8;
 
-    if (((maskedParams & 0x3F) != 0x1D) &&
+    if (((upperParams & 0x3F) != 0x1D) &&
         (g_Dop.status & PLAYER_STATUS_MIST_FORM)) {
         D_us_80181BFC = 0;
         DestroyEntity(self);
         return;
     }
 
-    if ((D_us_80181BFC) && maskedParams != 0x20 && maskedParams != 0x21 &&
-        ((maskedParams & 0x3F) != 0x1D)) {
+    if ((D_us_80181BFC) && upperParams != 0x20 && upperParams != 0x21 &&
+        ((upperParams & 0x3F) != 0x1D)) {
         DestroyEntity(self);
         return;
     }
@@ -2058,27 +2058,27 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
         return;
     }
 
-    sp72 = *sp5c++;
-    sp72 &= 0x7FFF;
+    dopSpriteIndex = *sp5c++;
+    dopSpriteIndex &= 0x7FFF;
 
     posX = self->posX.i.hi;
     posY = self->posY.i.hi;
 
     if (DOPPLEGANGER.animSet == (s16)ANIMSET_OVL(1)) {
-        sp58 = g_SpriteSheet[sp72];
+        plSprite = g_SpriteSheet[dopSpriteIndex];
     }
     if (DOPPLEGANGER.animSet == (s16)ANIMSET_OVL(2)) {
-        sp58 = (g_PlOvlDopBatSpritesheet)[sp72];
+        plSprite = (g_PlOvlDopBatSpritesheet)[dopSpriteIndex];
     }
 
-    var_s7 = 4;
-    var_s6 = 1;
-    sp7f = var_s7 + sp58[0];
-    sp7e = var_s6 + sp58[1];
-    xOffset = sp7f - var_s7;
-    yOffset = sp7e - var_s6;
-    sp7c = sp5c[0] + sp58[2];
-    sp7a = sp5c[1] + sp58[3];
+    xMargin = 4;
+    yMargin = 1;
+    wSprite = xMargin + plSprite[0];
+    hSprite = yMargin + plSprite[1];
+    xOffset = wSprite - xMargin; // TODO: or width
+    yOffset = hSprite - yMargin; // TODO: or height
+    xPivot = sp5c[0] + plSprite[2];
+    yPivot = sp5c[1] + plSprite[3];
 
     self->rotate = DOPPLEGANGER.rotate;
     self->drawFlags = DOPPLEGANGER.drawFlags;
@@ -2087,7 +2087,7 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
     self->rotPivotY = DOPPLEGANGER.rotPivotY;
     self->rotPivotX = DOPPLEGANGER.rotPivotX;
 
-    sp4c = D_us_8018192C[maskedParams & 0x3F];
+    dataPtr = D_us_8018192C[upperParams & 0x3F];
     switch (self->step) {
     case 0:
         if (func_8011BD48(self)) {
@@ -2104,45 +2104,45 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
         for (i = 0; i < 8; i++) {
             D_us_801818EC[i] = i << 9;
             prim->tpage = 0x10;
-            prim->clut = sp4c[3];
+            prim->clut = dataPtr[3];
             prim->r0 = prim->b0 = prim->g0 = prim->r1 = prim->b1 = prim->g1 =
                 prim->r2 = prim->b2 = prim->g2 = prim->r3 = prim->b3 =
                     prim->g3 = 0x80;
             prim->priority = DOPPLEGANGER.zPriority + 2;
 
-            prim->drawMode = sp4c[8] + DRAW_COLORS + DRAW_UNK02;
+            prim->drawMode = dataPtr[8] + DRAW_COLORS + DRAW_UNK02;
             prim = prim->next;
         }
-        self->ext.playerBlink.unk8A = sp4c[9];
-        self->ext.playerBlink.unk90 = 0;
+        self->ext.playerBlink.unk8A = dataPtr[9];
+        self->ext.playerBlink.colorIntensity = 0;
         self->ext.playerBlink.unk98 = 0;
         self->ext.playerBlink.unk9A = 0x100;
         self->step++;
-        if (maskedParams == 0x20) {
+        if (upperParams == 0x20) {
             self->step = 8;
         }
-        if (maskedParams == 0x21) {
+        if (upperParams == 0x21) {
             self->step = 0xA;
         }
         break;
     case 1:
-        if (sp4c[7] == 0x7008) {
-            self->ext.playerBlink.unk90 += 0x50;
+        if (dataPtr[7] == 0x7008) {
+            self->ext.playerBlink.colorIntensity += 0x50;
         } else {
-            self->ext.playerBlink.unk90 += 0xA;
+            self->ext.playerBlink.colorIntensity += 0xA;
         }
-        if (self->ext.playerBlink.unk90 > 0x100) {
-            self->ext.playerBlink.unk90 = 0x100;
-            self->ext.playerBlink.unk80 = sp4c[7];
+        if (self->ext.playerBlink.colorIntensity > 0x100) {
+            self->ext.playerBlink.colorIntensity = 0x100;
+            self->ext.playerBlink.unk80 = dataPtr[7];
             self->step++;
         }
         break;
     case 2:
-        if (sp4c[7] >= 0x7000) {
+        if (dataPtr[7] >= 0x7000) {
             self->ext.playerBlink.unk80 = 8;
-            switch ((u32)sp4c[7]) {
+            switch ((u32)dataPtr[7]) {
             case 0x7000:
-                if (g_Dop.timers[1] == 0) {
+                if (g_Dop.timers[ALU_T_CURSE] == 0) {
                     self->step++;
                 }
                 break;
@@ -2176,14 +2176,14 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
         }
         break;
     case 3:
-        self->ext.playerBlink.unk90 -= 10;
-        if (self->ext.playerBlink.unk90 < 0) {
+        self->ext.playerBlink.colorIntensity -= 10;
+        if (self->ext.playerBlink.colorIntensity < 0) {
             DestroyEntity(self);
             return;
         }
         break;
     case 8:
-        D_us_80181BFC = 1;
+        D_us_80181BFC = 1; // TODO: g_Dop.unk6C = 1;
         self->ext.playerBlink.unk98 += 8;
         self->ext.playerBlink.unk9C += 256;
         if (self->ext.playerBlink.unk98 > 128) {
@@ -2205,12 +2205,12 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
                 prim->clut = 0x15F;
                 prim = prim->next;
             }
-            D_us_80181BFC = 0;
+            D_us_80181BFC = 0; // TODO: g_Dop.unk6C = 0;
             return;
         }
         break;
     case 10:
-        D_us_80181BFC = 1;
+        D_us_80181BFC = 1; // TODO: g_Dop.unk6C = 1;
         self->ext.playerBlink.unk98 += 8;
         self->ext.playerBlink.unk9C += 0x100;
         if (self->ext.playerBlink.unk98 > 0x80) {
@@ -2226,20 +2226,20 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
     sp76 = self->ext.playerBlink.unk98;
     sp54 = 3;
     sp50 = 6;
-    if (sp4c[7] == 0x700A) {
+    if (dataPtr[7] == 0x700A) {
         sp50 = 0;
         sp54 = 0;
     }
     self->ext.playerBlink.unk82 += self->ext.playerBlink.unk8A;
     if (self->facingLeft) {
-        posX = posX - sp7c;
+        posX = posX - xPivot;
     } else {
-        posX = posX + sp7c;
+        posX = posX + xPivot;
     }
-    posY = posY + sp7a;
+    posY = posY + yPivot;
     prim = &g_PrimBuf[self->primIndex];
     for (i = 0; i < 8; i++) {
-        if (maskedParams & 0x40) {
+        if (upperParams & 0x40) {
             switch (i) {
             case 0:
                 if (self->facingLeft) {
@@ -2248,12 +2248,12 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
                     prim->x1 = posX + xOffset / 2;
                 }
                 prim->x0 = posX;
-                prim->u0 = var_s7;
-                prim->u1 = var_s7 + xOffset / 2;
+                prim->u0 = xMargin;
+                prim->u1 = xMargin + xOffset / 2;
                 prim->y1 = posY;
                 prim->y0 = posY;
-                prim->v1 = var_s6;
-                prim->v0 = var_s6;
+                prim->v1 = yMargin;
+                prim->v0 = yMargin;
                 break;
             case 1:
                 if (self->facingLeft) {
@@ -2263,10 +2263,10 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
                     prim->x0 = posX + xOffset / 2;
                     prim->x1 = posX + xOffset;
                 }
-                prim->u0 = var_s7 + xOffset / 2;
-                prim->u1 = var_s7 + xOffset;
+                prim->u0 = xMargin + xOffset / 2;
+                prim->u1 = xMargin + xOffset;
                 prim->y0 = prim->y1 = posY;
-                prim->v0 = prim->v1 = var_s6;
+                prim->v0 = prim->v1 = yMargin;
                 break;
             case 2:
                 if (self->facingLeft) {
@@ -2274,11 +2274,11 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
                 } else {
                     prim->x0 = prim->x1 = posX + xOffset;
                 }
-                prim->u0 = prim->u1 = var_s7 + xOffset;
+                prim->u0 = prim->u1 = xMargin + xOffset;
                 prim->y0 = posY;
                 prim->y1 = posY + yOffset / 2;
-                prim->v0 = var_s6;
-                prim->v1 = var_s6 + yOffset / 2;
+                prim->v0 = yMargin;
+                prim->v1 = yMargin + yOffset / 2;
                 break;
             case 3:
                 if (self->facingLeft) {
@@ -2287,11 +2287,11 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
                     prim->x0 = prim->x1 = posX + xOffset;
                 }
 
-                prim->u0 = prim->u1 = var_s7 + xOffset;
+                prim->u0 = prim->u1 = xMargin + xOffset;
                 prim->y0 = posY + yOffset / 2;
                 prim->y1 = posY + yOffset;
-                prim->v0 = var_s6 + yOffset / 2;
-                prim->v1 = var_s6 + yOffset;
+                prim->v0 = yMargin + yOffset / 2;
+                prim->v1 = yMargin + yOffset;
                 break;
             case 4:
                 if (self->facingLeft) {
@@ -2301,10 +2301,10 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
                     prim->x0 = posX + xOffset;
                     prim->x1 = posX + xOffset / 2;
                 }
-                prim->u0 = var_s7 + xOffset;
-                prim->u1 = var_s7 + xOffset / 2;
+                prim->u0 = xMargin + xOffset;
+                prim->u1 = xMargin + xOffset / 2;
                 prim->y0 = prim->y1 = posY + yOffset;
-                prim->v0 = prim->v1 = var_s6 + yOffset;
+                prim->v0 = prim->v1 = yMargin + yOffset;
                 break;
             case 5:
                 if (self->facingLeft) {
@@ -2313,31 +2313,31 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
                     prim->x0 = posX + xOffset / 2;
                 }
                 prim->x1 = posX;
-                prim->u0 = var_s7 + xOffset / 2;
-                prim->u1 = var_s7;
+                prim->u0 = xMargin + xOffset / 2;
+                prim->u1 = xMargin;
                 prim->y0 = prim->y1 = posY + yOffset;
-                prim->v0 = prim->v1 = var_s6 + yOffset;
+                prim->v0 = prim->v1 = yMargin + yOffset;
 
                 break;
             case 6:
                 prim->x1 = posX;
                 prim->x0 = posX;
-                prim->u1 = var_s7;
-                prim->u0 = var_s7;
+                prim->u1 = xMargin;
+                prim->u0 = xMargin;
                 prim->y0 = posY + yOffset;
                 prim->y1 = posY + yOffset / 2;
-                prim->v0 = var_s6 + yOffset;
-                prim->v1 = var_s6 + yOffset / 2;
+                prim->v0 = yMargin + yOffset;
+                prim->v1 = yMargin + yOffset / 2;
                 break;
             case 7:
                 prim->x1 = posX;
                 prim->x0 = posX;
-                prim->u1 = var_s7;
-                prim->u0 = var_s7;
+                prim->u1 = xMargin;
+                prim->u0 = xMargin;
                 prim->y0 = posY + yOffset / 2;
                 prim->y1 = posY;
-                prim->v0 = var_s6 + yOffset / 2;
-                prim->v1 = var_s6;
+                prim->v0 = yMargin + yOffset / 2;
+                prim->v1 = yMargin;
                 break;
             }
             if (self->facingLeft) {
@@ -2352,8 +2352,8 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
             prim->y2 = prim->y3 =
                 (posY + yOffset / 2) -
                 ((rsin(self->ext.playerBlink.unk82) >> 4) * sp50 >> 8);
-            prim->u2 = prim->u3 = var_s7 + xOffset / 2;
-            prim->v2 = prim->v3 = var_s6 + yOffset / 2;
+            prim->u2 = prim->u3 = xMargin + xOffset / 2;
+            prim->v2 = prim->v3 = yMargin + yOffset / 2;
         } else {
             if (self->facingLeft) {
                 prim->x0 = prim->x2 = (posX - xOffset) + 1;
@@ -2362,7 +2362,7 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
                 prim->x0 = prim->x2 = posX;
                 prim->x1 = prim->x3 = posX + xOffset;
             }
-            if (maskedParams == 0x20 || maskedParams == 0x21) {
+            if (upperParams == 0x20 || upperParams == 0x21) {
                 sp74 = (rsin(sp78) >> 7) * sp76 / 256;
                 prim->x0 += sp74;
                 prim->x1 += sp74;
@@ -2374,55 +2374,55 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
             prim->y0 = prim->y1 = posY + yOffset * i / 8;
             prim->y2 = prim->y3 = posY + yOffset * (i + 1) / 8;
             if (self->facingLeft) {
-                prim->u0 = prim->u2 = sp7f - 1;
-                prim->u1 = prim->u3 = var_s7 - 1;
+                prim->u0 = prim->u2 = wSprite - 1;
+                prim->u1 = prim->u3 = xMargin - 1;
             } else {
-                prim->u0 = prim->u2 = var_s7;
-                prim->u1 = prim->u3 = sp7f;
+                prim->u0 = prim->u2 = xMargin;
+                prim->u1 = prim->u3 = wSprite;
             }
-            prim->v0 = prim->v1 = var_s6 + yOffset * i / 8;
-            prim->v2 = prim->v3 = var_s6 + yOffset * (i + 1) / 8;
+            prim->v0 = prim->v1 = yMargin + yOffset * i / 8;
+            prim->v2 = prim->v3 = yMargin + yOffset * (i + 1) / 8;
         }
 
         g_api.func_800EB758(self->posX.i.hi, self->posY.i.hi, self,
                             self->drawFlags, (POLY_GT4*)prim, self->facingLeft);
 
-        if (maskedParams != 0x20 && maskedParams != 0x21) {
-            sp6e = sp4c[0];
-            sp6c = sp4c[2];
-            sp6a = sp4c[1];
-            sp68 = sp4c[4];
-            sp64 = sp4c[6];
-            sp66 = sp4c[5];
+        if (upperParams != 0x20 && upperParams != 0x21) {
+            angleRedIndex = dataPtr[0];
+            angleGreenIndex = dataPtr[2];
+            angleBlueIndex = dataPtr[1];
+            redDivide = dataPtr[4];
+            greenDivide = dataPtr[6];
+            blueDivide = dataPtr[5];
             // clang-format off
-            if (maskedParams & 0x40) {
-                angle = D_us_801818EC[(i + sp6e) % 8];
-                prim->r0 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp68);
-                angle = D_us_801818EC[(i + sp6c) % 8];
-                prim->g0 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp64);
-                angle = D_us_801818EC[(i + sp6a) % 8];
-                prim->b0 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp66);
-                angle = D_us_801818EC[(i + sp6e + 1) % 8];
-                prim->r1 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp68);
-                angle = D_us_801818EC[(i + sp6c + 1) % 8];
-                prim->g1 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp64);
-                angle = D_us_801818EC[(i + sp6a + 1) % 8];
-                prim->b1 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp66);
+            if (upperParams & 0x40) {
+                angle = D_us_801818EC[(i + angleRedIndex) % 8];
+                prim->r0 = (((rsin(angle) + FLT(1.0)) >> 6) * self->ext.playerBlink.colorIntensity / redDivide);
+                angle = D_us_801818EC[(i + angleGreenIndex) % 8];
+                prim->g0 = (((rsin(angle) + FLT(1.0)) >> 6) * self->ext.playerBlink.colorIntensity / greenDivide);
+                angle = D_us_801818EC[(i + angleBlueIndex) % 8];
+                prim->b0 = (((rsin(angle) + FLT(1.0)) >> 6) * self->ext.playerBlink.colorIntensity / blueDivide);
+                angle = D_us_801818EC[(i + angleRedIndex + 1) % 8];
+                prim->r1 = (((rsin(angle) + FLT(1.0)) >> 6) * self->ext.playerBlink.colorIntensity / redDivide);
+                angle = D_us_801818EC[(i + angleGreenIndex + 1) % 8];
+                prim->g1 = (((rsin(angle) + FLT(1.0)) >> 6) * self->ext.playerBlink.colorIntensity / greenDivide);
+                angle = D_us_801818EC[(i + angleBlueIndex + 1) % 8];
+                prim->b1 = (((rsin(angle) + FLT(1.0)) >> 6) * self->ext.playerBlink.colorIntensity / blueDivide);
                 prim->r2 = prim->g2 = prim->b2 = prim->r3 = prim->g3 = prim->b3 = 0;
                 D_us_801818EC[i] += self->ext.playerBlink.unk8A;
             } else {
-                angle = D_us_801818EC[(i + sp6e) % 8];
-                prim->r0 = prim->r1 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp68);
-                angle = D_us_801818EC[(i + sp6c) % 8];
-                prim->g0 = prim->g1 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp64);
-                angle = D_us_801818EC[(i + sp6a) % 8];
-                prim->b0 = prim->b1 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp66);
-                angle = D_us_801818EC[(i + sp6e + 1) % 8];
-                prim->r2 = prim->r3 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp68);
-                angle = D_us_801818EC[(i + sp6c + 1) % 8];
-                prim->g2 = prim->g3 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp64);
-                angle = D_us_801818EC[(i + sp6a + 1) % 8];
-                prim->b2 = prim->b3 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp66);
+                angle = D_us_801818EC[(i + angleRedIndex) % 8];
+                prim->r0 = prim->r1 =(((rsin(angle) + FLT(1.0)) >> 6) * self->ext.playerBlink.colorIntensity / redDivide);
+                angle = D_us_801818EC[(i + angleGreenIndex) % 8];
+                prim->g0 = prim->g1 =(((rsin(angle) + FLT(1.0)) >> 6) * self->ext.playerBlink.colorIntensity / greenDivide);
+                angle = D_us_801818EC[(i + angleBlueIndex) % 8];
+                prim->b0 = prim->b1 =(((rsin(angle) + FLT(1.0)) >> 6) * self->ext.playerBlink.colorIntensity / blueDivide);
+                angle = D_us_801818EC[(i + angleRedIndex + 1) % 8];
+                prim->r2 = prim->r3 =(((rsin(angle) + FLT(1.0)) >> 6) * self->ext.playerBlink.colorIntensity / redDivide);
+                angle = D_us_801818EC[(i + angleGreenIndex + 1) % 8];
+                prim->g2 = prim->g3 =(((rsin(angle) + FLT(1.0)) >> 6) * self->ext.playerBlink.colorIntensity / greenDivide);
+                angle = D_us_801818EC[(i + angleBlueIndex + 1) % 8];
+                prim->b2 = prim->b3 =(((rsin(angle) + FLT(1.0)) >> 6) * self->ext.playerBlink.colorIntensity / blueDivide);
                 D_us_801818EC[i] += self->ext.playerBlink.unk8A;
             }
         }
@@ -2430,7 +2430,8 @@ void EntityDopplegangerBlinkWhite(Entity* self) {
         prim = prim->next;
     }
     func_us_801C4954(1, 1);
-    if (((maskedParams & 0x3F) == 0) || ((maskedParams & 0x3F) == 7)) {
+    if (((upperParams & 0x3F) == 0) || ((upperParams & 0x3F) == 7)) {
+        // set invincibility frames
         func_us_801C4A30(1, 0xA);
     }
 }
diff --git a/src/dra/7879C.c b/src/dra/7879C.c
index 233af0dbd3..315e24398e 100644
--- a/src/dra/7879C.c
+++ b/src/dra/7879C.c
@@ -2325,36 +2325,36 @@ static bool func_8011BD48(Entity* entity) {
 // player turns white for some sort of status effect
 void EntityPlayerBlinkWhite(Entity* self) {
     Primitive* prim;
-    u8 var_s7;
-    u8 var_s6;
-    u8 sp7f;
-    u8 sp7e;
-    s16 sp7c;
-    s16 sp7a;
-    s16 var_s2;
-    s16 var_s5;
+    u8 xMargin;
+    u8 yMargin;
+    u8 wSprite;
+    u8 hSprite;
+    s16 xPivot;
+    s16 yPivot;
+    s16 width;
+    s16 height;
     s16 sp78;
     s16 sp76;
     s16 sp74;
-    s16 sp72;
-    s16 var_s3;
-    s16 var_s8;
+    s16 plSpriteIndex;
+    s16 selfX;
+    s16 selfY;
     s16* sp5c;
-    u8* sp58;
+    u8* plSprite;
     s32 sp54;
     s32 sp50;
 
-    s16 sp70;
+    s16 upperParams;
 
-    s16* sp4c;
-    s32 var_s1;
+    s16* dataPtr;
+    s32 i;
     s16 angle;
-    s16 sp6e;
-    s16 sp6c;
-    s16 sp6a;
-    s16 sp68;
-    s16 sp66;
-    s16 sp64;
+    s16 angleRedIndex;
+    s16 angleGreenIndex;
+    s16 angleBlueIndex;
+    s16 redDivide;
+    s16 blueDivide;
+    s16 greenDivide;
     s16 sp62;
     s16 sp60;
 
@@ -2364,32 +2364,35 @@ void EntityPlayerBlinkWhite(Entity* self) {
     Entity* sp3C;
     s32 sp38;
 
-    sp70 = (self->params & 0x7F00) >> 8;
+    upperParams = (self->params & 0x7F00) >> 8;
     sp48 = 0;
-    if ((PLAYER.animSet == 0xF) && (sp70 == 0x23) && g_Player.unk66 < 2) {
+    if ((PLAYER.animSet == 0xF) && (upperParams == 0x23) &&
+        g_Player.unk66 < 2) {
         sp48 = 1;
     }
-    if ((((sp70 & 0x3F) != 0x1D) &&
+    if ((((upperParams & 0x3F) != 0x1D) &&
          (g_Player.status & PLAYER_STATUS_MIST_FORM)) ||
         (g_Player.status & PLAYER_STATUS_AXEARMOR)) {
-        goto block_229;
+        goto set_unk6C_unk6E_0;
     }
-    if ((g_Player.unk6C) && sp70 != 0x20 && sp70 != 0x21 &&
-        ((sp70 & 0x3F) != 0x1D)) {
+    if ((g_Player.unk6C) && upperParams != 0x20 && upperParams != 0x21 &&
+        ((upperParams & 0x3F) != 0x1D)) {
         g_Player.unk6E = 0;
-        goto block_231;
+        DestroyEntity(self);
+        return;
     }
-    if ((g_Player.unk6E) && sp70 != 0x23 && sp70 != 0x24 &&
-        ((sp70 & 0x3F) != 0x1D)) {
+    if ((g_Player.unk6E) && upperParams != 0x23 && upperParams != 0x24 &&
+        ((upperParams & 0x3F) != 0x1D)) {
         g_Player.unk6C = 0;
-        goto block_231;
+        DestroyEntity(self);
+        return;
     }
     if (((PLAYER.step == Player_SpellHellfire) && (PLAYER.palette == 0x810D)) ||
         (!PLAYER.animSet) || !(PLAYER.animCurFrame & 0x7FFF)) {
-        goto block_229;
+        goto set_unk6C_unk6E_0;
     }
-    var_s8 = self->posY.i.hi = PLAYER.posY.i.hi;
-    var_s3 = self->posX.i.hi = PLAYER.posX.i.hi;
+    selfY = self->posY.i.hi = PLAYER.posY.i.hi;
+    selfX = self->posX.i.hi = PLAYER.posX.i.hi;
     self->facingLeft = PLAYER.facingLeft;
     if (PLAYER.animSet == 1) {
         sp5c = D_800CF324[PLAYER.animCurFrame & 0x7FFF];
@@ -2404,12 +2407,12 @@ void EntityPlayerBlinkWhite(Entity* self) {
 #ifdef VERSION_PSP
                 if (sp5c) {
 #endif
-                    sp72 = *sp5c++;
-                    sp72 &= 0x7FFF;
-                    sp58 = (*g_PlOvlAluBatSpritesheet)[sp72];
+                    plSpriteIndex = *sp5c++;
+                    plSpriteIndex &= 0x7FFF;
+                    plSprite = (*g_PlOvlAluBatSpritesheet)[plSpriteIndex];
 #ifdef VERSION_PSP
                 } else {
-                    sp58 = 0;
+                    plSprite = 0;
                 }
 #endif
             } else {
@@ -2417,72 +2420,72 @@ void EntityPlayerBlinkWhite(Entity* self) {
 #ifdef VERSION_PSP
                 if (sp5c) {
 #endif
-                    sp72 = *sp5c++;
-                    sp72 &= 0x7FFF;
-                    sp58 = ((u8**)SPRITESHEET_PTR)[sp72];
+                    plSpriteIndex = *sp5c++;
+                    plSpriteIndex &= 0x7FFF;
+                    plSprite = ((u8**)SPRITESHEET_PTR)[plSpriteIndex];
 #ifdef VERSION_PSP
                 } else {
-                    sp58 = 0;
+                    plSprite = 0;
                 }
 #endif
             }
         } else {
-            sp7c = 0x2C;
+            xPivot = 0x2C;
             if (PLAYER.facingLeft) {
 #ifdef VERSION_PSP
-                sp7c = 0x13;
+                xPivot = 0x13;
 #else
-                sp7c = 0x14;
+                xPivot = 0x14;
 #endif
             }
-            var_s7 = sp7c + D_8013AEBC[2];
-            sp7f = sp7c + D_8013AEBC[0];
+            xMargin = xPivot + D_8013AEBC[2];
+            wSprite = xPivot + D_8013AEBC[0];
 #ifdef VERSION_PSP
-            var_s6 = D_8013AEBC[3] + 24;
+            yMargin = D_8013AEBC[3] + 24;
 #else
-            var_s6 = D_8013AEBC[3] - 40;
+            yMargin = D_8013AEBC[3] - 40;
 #endif
-            sp7e = D_8013AEBC[1] + 24;
-            var_s2 = D_8013AEBC[0] - D_8013AEBC[2];
-            var_s5 = D_8013AEBC[1] - D_8013AEBC[3];
-            sp7c = D_8013AEBC[2];
-            sp7a = D_8013AEBC[3];
+            hSprite = D_8013AEBC[1] + 24;
+            width = D_8013AEBC[0] - D_8013AEBC[2];
+            height = D_8013AEBC[1] - D_8013AEBC[3];
+            xPivot = D_8013AEBC[2];
+            yPivot = D_8013AEBC[3];
             self->facingLeft = 0;
             self->drawFlags = FLAG_DRAW_DEFAULT;
             goto block_748;
         }
     } else {
-        sp72 = *sp5c++;
-        sp72 &= 0x7FFF;
+        plSpriteIndex = *sp5c++;
+        plSpriteIndex &= 0x7FFF;
         if (PLAYER.animSet == 1) {
-            sp58 = ((u8**)SPRITESHEET_PTR)[sp72];
+            plSprite = ((u8**)SPRITESHEET_PTR)[plSpriteIndex];
         }
         if (PLAYER.animSet == 0xD) {
-            sp58 = (*g_PlOvlAluBatSpritesheet)[sp72];
+            plSprite = (*g_PlOvlAluBatSpritesheet)[plSpriteIndex];
         }
     }
 #ifdef VERSION_PSP
-    if (sp58) {
+    if (plSprite) {
 #endif
-        var_s7 = 4;
-        var_s6 = 1;
-        sp7f = var_s7 + sp58[0];
-        sp7e = var_s6 + sp58[1];
-        var_s2 = sp7f - var_s7;
-        var_s5 = sp7e - var_s6;
-        sp7c = sp5c[0] + sp58[2];
-        sp7a = sp5c[1] + sp58[3];
+        xMargin = 4;
+        yMargin = 1;
+        wSprite = xMargin + plSprite[0];
+        hSprite = yMargin + plSprite[1];
+        width = wSprite - xMargin;
+        height = hSprite - yMargin;
+        xPivot = sp5c[0] + plSprite[2];
+        yPivot = sp5c[1] + plSprite[3];
 #ifdef VERSION_PSP
 
     } else {
-        var_s7 = 4;
-        var_s6 = 1;
-        sp7f = var_s7 + 0;
-        sp7e = var_s6 + 0;
-        var_s2 = sp7f - var_s7;
-        var_s5 = sp7e - var_s6;
-        sp7c = 0;
-        sp7a = 0;
+        xMargin = 4;
+        yMargin = 1;
+        wSprite = xMargin + 0;
+        hSprite = yMargin + 0;
+        width = wSprite - xMargin;
+        height = hSprite - yMargin;
+        xPivot = 0;
+        yPivot = 0;
     }
 #endif
 
@@ -2493,11 +2496,12 @@ void EntityPlayerBlinkWhite(Entity* self) {
     self->rotPivotY = PLAYER.rotPivotY;
     self->rotPivotX = PLAYER.rotPivotX;
 block_748:
-    sp4c = D_800AD670[sp70 & 0x3F];
+    dataPtr = D_800AD670[upperParams & 0x3F];
     switch (self->step) {
     case 0:
         if (func_8011BD48(self) != 0) {
-            goto block_231;
+            DestroyEntity(self);
+            return;
         }
         self->primIndex = AllocPrimitives(PRIM_GT4, 8);
         if (self->primIndex == -1) {
@@ -2509,63 +2513,64 @@ void EntityPlayerBlinkWhite(Entity* self) {
         self->flags = FLAG_KEEP_ALIVE_OFFCAMERA | FLAG_HAS_PRIMS |
                       FLAG_POS_PLAYER_LOCKED | FLAG_UNK_20000 | FLAG_UNK_10000;
         prim = &g_PrimBuf[self->primIndex];
-        for (var_s1 = 0; var_s1 < 8; var_s1++) {
-            D_800AD630[var_s1] = var_s1 << 9;
-            prim->clut = sp4c[3];
+        for (i = 0; i < 8; i++) {
+            D_800AD630[i] = i << 9;
+            prim->clut = dataPtr[3];
             prim->r0 = prim->b0 = prim->g0 = prim->r1 = prim->b1 = prim->g1 =
                 prim->r2 = prim->b2 = prim->g2 = prim->r3 = prim->b3 =
                     prim->g3 = 0x80;
             prim->priority = PLAYER.zPriority + 2;
-            if (sp70 == 0x20 || sp70 == 0x21 || sp70 == 0x23 || sp70 == 0x24) {
+            if (upperParams == 0x20 || upperParams == 0x21 ||
+                upperParams == 0x23 || upperParams == 0x24) {
                 prim->priority = PLAYER.zPriority + 4;
             }
             prim->drawMode =
-                sp4c[8] + DRAW_UNK_200 + DRAW_UNK_100 + DRAW_COLORS;
+                dataPtr[8] + DRAW_UNK_200 + DRAW_UNK_100 + DRAW_COLORS;
             prim = prim->next;
         }
-        self->ext.playerBlink.unk8A = sp4c[9];
-        self->ext.playerBlink.unk90 = 0;
+        self->ext.playerBlink.unk8A = dataPtr[9];
+        self->ext.playerBlink.colorIntensity = 0;
         self->ext.playerBlink.unk98 = 0;
         self->ext.playerBlink.unk9A = 0x100;
         self->step += 1;
-        if (sp70 == 0x20) {
+        if (upperParams == 0x20) {
             self->step = 8;
         }
-        if (sp70 == 0x21) {
+        if (upperParams == 0x21) {
             self->step = 0xA;
         }
-        if (sp70 == 0x23) {
+        if (upperParams == 0x23) {
             self->step = 0xC;
         }
-        if (sp70 == 0x24) {
+        if (upperParams == 0x24) {
             self->step = 0xE;
         }
-        if (sp70 == 0x26) {
+        if (upperParams == 0x26) {
             self->step = 0x10;
         }
-        if (sp70 == 0x29) {
-            self->ext.playerBlink.unk90 = 0xFF;
+        if (upperParams == 0x29) {
+            self->ext.playerBlink.colorIntensity = 0xFF;
             self->step = 0x13;
         }
         break;
     case 1:
-        if (sp4c[7] == 0x7008) {
-            self->ext.playerBlink.unk90 += 0x50;
+        if (dataPtr[7] == 0x7008) {
+            self->ext.playerBlink.colorIntensity += 0x50;
         } else {
-            self->ext.playerBlink.unk90 += 0xA;
+            self->ext.playerBlink.colorIntensity += 0xA;
         }
-        if (self->ext.playerBlink.unk90 > 0x100) {
-            self->ext.playerBlink.unk90 = 0x100;
-            self->ext.playerBlink.unk80 = sp4c[7];
+        if (self->ext.playerBlink.colorIntensity > 0x100) {
+            self->ext.playerBlink.colorIntensity = 0x100;
+            self->ext.playerBlink.unk80 = dataPtr[7];
             self->step += 1;
         }
         break;
     case 2:
-        if (sp4c[7] >= 0x7000) {
+        if (dataPtr[7] >= 0x7000) {
             self->ext.playerBlink.unk80 = 8;
-            switch ((u32)sp4c[7]) {
+            switch ((u32)dataPtr[7]) {
             case 0x7000:
-                if (g_Player.timers[1] == 0) {
+                if (g_Player.timers[ALU_T_CURSE] == 0) {
                     self->step += 1;
                 }
                 break;
@@ -2576,16 +2581,17 @@ void EntityPlayerBlinkWhite(Entity* self) {
                 }
                 break;
             case 0x7002:
-                sp40 = g_Player.timers[0];
+                sp40 = g_Player.timers[ALU_T_POISON];
                 if (sp40 == 0) {
                     self->step += 1;
                 }
-                self->ext.playerBlink.unk90 = ((sp40 * 192) / 4095) + 0x10;
+                self->ext.playerBlink.colorIntensity =
+                    ((sp40 * 192) / 4095) + 0x10;
                 break;
             case 0x7003:
                 sp38 = 0;
                 sp3C = &g_Entities[32];
-                for (var_s1 = 0; var_s1 < 16; var_s1++) {
+                for (i = 0; i < 16; i++) {
                     if (sp3C->entityId == 0x11) {
                         sp38 += 1;
                     }
@@ -2631,9 +2637,9 @@ void EntityPlayerBlinkWhite(Entity* self) {
         }
         break;
     case 3:
-        self->ext.playerBlink.unk90 -= 10;
-        if (self->ext.playerBlink.unk90 < 0) {
-            goto block_231;
+        self->ext.playerBlink.colorIntensity -= 10;
+        if (self->ext.playerBlink.colorIntensity < 0) {
+            goto destroy_entity;
         }
         break;
     case 8:
@@ -2662,7 +2668,7 @@ void EntityPlayerBlinkWhite(Entity* self) {
             self->params = 0x1B00;
             self->step = 1;
             prim = &g_PrimBuf[self->primIndex];
-            for (var_s1 = 0; var_s1 < 8; var_s1++) {
+            for (i = 0; i < 8; i++) {
                 prim->clut = 0x15F;
                 prim = prim->next;
             }
@@ -2721,7 +2727,7 @@ void EntityPlayerBlinkWhite(Entity* self) {
             self->params = 0x1B00;
             self->step = 1;
             prim = &g_PrimBuf[self->primIndex];
-            for (var_s1 = 0; var_s1 < 8; var_s1++) {
+            for (i = 0; i < 8; i++) {
                 prim->clut = 0x15F;
                 prim = prim->next;
             }
@@ -2737,35 +2743,35 @@ void EntityPlayerBlinkWhite(Entity* self) {
         }
         break;
     case 19:
-        self->ext.playerBlink.unk90 -= 2;
-        if (self->ext.playerBlink.unk90 < 0) {
+        self->ext.playerBlink.colorIntensity -= 2;
+        if (self->ext.playerBlink.colorIntensity < 0) {
             DestroyEntity(self);
             return;
         }
         break;
     }
     sp44 = 0;
-    if (sp70 == 0x20 || sp70 == 0x21 || sp70 == 0x23 || sp70 == 0x24 ||
-        sp70 == 0x26) {
+    if (upperParams == 0x20 || upperParams == 0x21 || upperParams == 0x23 ||
+        upperParams == 0x24 || upperParams == 0x26) {
         sp44 = 1;
     }
     sp78 = self->ext.playerBlink.unk9C;
     sp76 = self->ext.playerBlink.unk98;
     sp54 = 3;
     sp50 = 6;
-    if (sp4c[7] == 0x700A) {
+    if (dataPtr[7] == 0x700A) {
         sp50 = 0;
         sp54 = 0;
     }
     self->ext.playerBlink.unk82 += self->ext.playerBlink.unk8A;
     if (self->facingLeft) {
-        var_s3 = var_s3 - sp7c;
+        selfX = selfX - xPivot;
     } else {
-        var_s3 = var_s3 + sp7c;
+        selfX = selfX + xPivot;
     }
-    var_s8 = var_s8 + sp7a;
+    selfY = selfY + yPivot;
     prim = &g_PrimBuf[self->primIndex];
-    for (var_s1 = 0; var_s1 < 8; var_s1++) {
+    for (i = 0; i < 8; i++) {
         if (PLAYER.animSet == 0xF && sp48 == 0) {
 #ifdef VERSION_PSP
             prim->tpage = 0x4118;
@@ -2775,130 +2781,130 @@ void EntityPlayerBlinkWhite(Entity* self) {
         } else {
             prim->tpage = 0x18;
         }
-        if (sp70 & 0x40) {
-            switch (var_s1) {
+        if (upperParams & 0x40) {
+            switch (i) {
             case 0:
                 if (self->facingLeft) {
-                    prim->x1 = var_s3 - var_s2 / 2;
+                    prim->x1 = selfX - width / 2;
                 } else {
-                    prim->x1 = var_s3 + var_s2 / 2;
+                    prim->x1 = selfX + width / 2;
                 }
-                prim->x0 = var_s3;
-                prim->u0 = var_s7;
-                prim->u1 = var_s7 + var_s2 / 2;
-                prim->y1 = var_s8;
-                prim->y0 = var_s8;
-                prim->v1 = var_s6;
-                prim->v0 = var_s6;
+                prim->x0 = selfX;
+                prim->u0 = xMargin;
+                prim->u1 = xMargin + width / 2;
+                prim->y1 = selfY;
+                prim->y0 = selfY;
+                prim->v1 = yMargin;
+                prim->v0 = yMargin;
                 break;
             case 1:
                 if (self->facingLeft) {
-                    prim->x0 = var_s3 - var_s2 / 2;
-                    prim->x1 = var_s3 - var_s2;
+                    prim->x0 = selfX - width / 2;
+                    prim->x1 = selfX - width;
                 } else {
-                    prim->x0 = var_s3 + var_s2 / 2;
-                    prim->x1 = var_s3 + var_s2;
+                    prim->x0 = selfX + width / 2;
+                    prim->x1 = selfX + width;
                 }
-                prim->u0 = var_s7 + var_s2 / 2;
-                prim->u1 = var_s7 + var_s2;
-                prim->y1 = var_s8;
-                prim->y0 = var_s8;
-                prim->v1 = var_s6;
-                prim->v0 = var_s6;
+                prim->u0 = xMargin + width / 2;
+                prim->u1 = xMargin + width;
+                prim->y1 = selfY;
+                prim->y0 = selfY;
+                prim->v1 = yMargin;
+                prim->v0 = yMargin;
                 break;
             case 2:
                 if (self->facingLeft) {
-                    prim->x0 = prim->x1 = var_s3 - var_s2;
+                    prim->x0 = prim->x1 = selfX - width;
                 } else {
-                    prim->x0 = prim->x1 = var_s3 + var_s2;
+                    prim->x0 = prim->x1 = selfX + width;
                 }
-                prim->u0 = prim->u1 = var_s7 + var_s2;
-                prim->y0 = var_s8;
-                prim->y1 = var_s8 + var_s5 / 2;
-                prim->v0 = var_s6;
-                prim->v1 = var_s6 + var_s5 / 2;
+                prim->u0 = prim->u1 = xMargin + width;
+                prim->y0 = selfY;
+                prim->y1 = selfY + height / 2;
+                prim->v0 = yMargin;
+                prim->v1 = yMargin + height / 2;
                 break;
             case 3:
                 if (self->facingLeft) {
-                    prim->x0 = prim->x1 = var_s3 - var_s2;
+                    prim->x0 = prim->x1 = selfX - width;
                 } else {
-                    prim->x0 = prim->x1 = var_s3 + var_s2;
+                    prim->x0 = prim->x1 = selfX + width;
                 }
 
-                prim->u0 = prim->u1 = var_s7 + var_s2;
-                prim->y0 = var_s8 + var_s5 / 2;
-                prim->y1 = var_s8 + var_s5;
-                prim->v0 = var_s6 + var_s5 / 2;
-                prim->v1 = var_s6 + var_s5;
+                prim->u0 = prim->u1 = xMargin + width;
+                prim->y0 = selfY + height / 2;
+                prim->y1 = selfY + height;
+                prim->v0 = yMargin + height / 2;
+                prim->v1 = yMargin + height;
                 break;
             case 4:
                 if (self->facingLeft) {
-                    prim->x0 = var_s3 - var_s2;
-                    prim->x1 = var_s3 - var_s2 / 2;
+                    prim->x0 = selfX - width;
+                    prim->x1 = selfX - width / 2;
                 } else {
-                    prim->x0 = var_s3 + var_s2;
-                    prim->x1 = var_s3 + var_s2 / 2;
+                    prim->x0 = selfX + width;
+                    prim->x1 = selfX + width / 2;
                 }
-                prim->u0 = var_s7 + var_s2;
-                prim->u1 = var_s7 + var_s2 / 2;
-                prim->y0 = prim->y1 = var_s8 + var_s5;
-                prim->v0 = prim->v1 = var_s6 + var_s5;
+                prim->u0 = xMargin + width;
+                prim->u1 = xMargin + width / 2;
+                prim->y0 = prim->y1 = selfY + height;
+                prim->v0 = prim->v1 = yMargin + height;
                 break;
             case 5:
                 if (self->facingLeft) {
-                    prim->x0 = var_s3 - var_s2 / 2;
+                    prim->x0 = selfX - width / 2;
                 } else {
-                    prim->x0 = var_s3 + var_s2 / 2;
+                    prim->x0 = selfX + width / 2;
                 }
-                prim->x1 = var_s3;
-                prim->u0 = var_s7 + var_s2 / 2;
-                prim->u1 = var_s7;
-                prim->y0 = prim->y1 = var_s8 + var_s5;
-                prim->v0 = prim->v1 = var_s6 + var_s5;
+                prim->x1 = selfX;
+                prim->u0 = xMargin + width / 2;
+                prim->u1 = xMargin;
+                prim->y0 = prim->y1 = selfY + height;
+                prim->v0 = prim->v1 = yMargin + height;
 
                 break;
             case 6:
-                prim->x1 = var_s3;
-                prim->x0 = var_s3;
-                prim->u1 = var_s7;
-                prim->u0 = var_s7;
-                prim->y0 = var_s8 + var_s5;
-                prim->y1 = var_s8 + var_s5 / 2;
-                prim->v0 = var_s6 + var_s5;
-                prim->v1 = var_s6 + var_s5 / 2;
+                prim->x1 = selfX;
+                prim->x0 = selfX;
+                prim->u1 = xMargin;
+                prim->u0 = xMargin;
+                prim->y0 = selfY + height;
+                prim->y1 = selfY + height / 2;
+                prim->v0 = yMargin + height;
+                prim->v1 = yMargin + height / 2;
                 break;
             case 7:
-                prim->x1 = var_s3;
-                prim->x0 = var_s3;
-                prim->u1 = var_s7;
-                prim->u0 = var_s7;
-                prim->y0 = var_s8 + var_s5 / 2;
-                prim->y1 = var_s8;
-                prim->v0 = var_s6 + var_s5 / 2;
-                prim->v1 = var_s6;
+                prim->x1 = selfX;
+                prim->x0 = selfX;
+                prim->u1 = xMargin;
+                prim->u0 = xMargin;
+                prim->y0 = selfY + height / 2;
+                prim->y1 = selfY;
+                prim->v0 = yMargin + height / 2;
+                prim->v1 = yMargin;
                 break;
             }
             if (self->facingLeft) {
                 prim->x2 = prim->x3 =
-                    var_s3 - var_s2 / 2 +
+                    selfX - width / 2 +
                     ((rcos(self->ext.playerBlink.unk82) >> 4) * sp54 >> 0xC);
             } else {
                 prim->x2 = prim->x3 =
-                    var_s3 + var_s2 / 2 +
+                    selfX + width / 2 +
                     ((rcos(self->ext.playerBlink.unk82) >> 4) * sp54 >> 0xC);
             }
             prim->y2 = prim->y3 =
-                (var_s8 + var_s5 / 2) -
+                (selfY + height / 2) -
                 ((rsin(self->ext.playerBlink.unk82) >> 4) * sp50 >> 8);
-            prim->u2 = prim->u3 = var_s7 + var_s2 / 2;
-            prim->v2 = prim->v3 = var_s6 + var_s5 / 2;
+            prim->u2 = prim->u3 = xMargin + width / 2;
+            prim->v2 = prim->v3 = yMargin + height / 2;
         } else {
             if (self->facingLeft) {
-                prim->x0 = prim->x2 = (var_s3 - var_s2) + 1;
-                prim->x1 = prim->x3 = var_s3 + 1;
+                prim->x0 = prim->x2 = (selfX - width) + 1;
+                prim->x1 = prim->x3 = selfX + 1;
             } else {
-                prim->x0 = prim->x2 = var_s3;
-                prim->x1 = prim->x3 = var_s3 + var_s2;
+                prim->x0 = prim->x2 = selfX;
+                prim->x1 = prim->x3 = selfX + width;
             }
             if (sp44 != 0) {
                 sp74 = (rsin(sp78) >> 7) * sp76 / 256;
@@ -2909,17 +2915,17 @@ void EntityPlayerBlinkWhite(Entity* self) {
                 prim->x2 += sp74;
                 prim->x3 += sp74;
             }
-            prim->y0 = prim->y1 = var_s8 + var_s5 * var_s1 / 8;
-            prim->y2 = prim->y3 = var_s8 + var_s5 * (var_s1 + 1) / 8;
+            prim->y0 = prim->y1 = selfY + height * i / 8;
+            prim->y2 = prim->y3 = selfY + height * (i + 1) / 8;
             if (self->facingLeft) {
-                prim->u0 = prim->u2 = sp7f - 1;
-                prim->u1 = prim->u3 = var_s7 - 1;
+                prim->u0 = prim->u2 = wSprite - 1;
+                prim->u1 = prim->u3 = xMargin - 1;
             } else {
-                prim->u0 = prim->u2 = var_s7;
-                prim->u1 = prim->u3 = sp7f;
+                prim->u0 = prim->u2 = xMargin;
+                prim->u1 = prim->u3 = wSprite;
             }
-            prim->v0 = prim->v1 = var_s6 + var_s5 * var_s1 / 8;
-            prim->v2 = prim->v3 = var_s6 + var_s5 * (var_s1 + 1) / 8;
+            prim->v0 = prim->v1 = yMargin + height * i / 8;
+            prim->v2 = prim->v3 = yMargin + height * (i + 1) / 8;
         }
         if (self->drawFlags &
             (FLAG_DRAW_SCALEX | FLAG_DRAW_SCALEY | FLAG_DRAW_ROTATE)) {
@@ -2927,62 +2933,85 @@ void EntityPlayerBlinkWhite(Entity* self) {
                           self->drawFlags, prim, self->facingLeft);
         }
         if (sp44 == 0) {
-            if (sp70 == 0x29) {
+            if (upperParams == 0x29) {
                 prim->r0 = prim->b0 = prim->g0 = prim->r1 = prim->b1 =
                     prim->g1 = prim->r2 = prim->b2 = prim->g2 = prim->r3 =
-                        prim->b3 = prim->g3 = self->ext.playerBlink.unk90;
+                        prim->b3 = prim->g3 =
+                            self->ext.playerBlink.colorIntensity;
             } else {
-                sp6e = sp4c[0];
-                sp6c = sp4c[2];
-                sp6a = sp4c[1];
-                sp68 = sp4c[4];
-                sp64 = sp4c[6];
-                sp66 = sp4c[5];
-                // clang-format off
-                if (sp70 & 0x40) {
-                    angle = D_800AD630[(var_s1 + sp6e) % 8];
-                    prim->r0 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp68);
-                    angle = D_800AD630[(var_s1 + sp6c) % 8];
-                    prim->g0 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp64);
-                    angle = D_800AD630[(var_s1 + sp6a) % 8];
-                    prim->b0 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp66);
-                    angle = D_800AD630[(var_s1 + sp6e + 1) % 8];
-                    prim->r1 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp68);
-                    angle = D_800AD630[(var_s1 + sp6c + 1) % 8];
-                    prim->g1 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp64);
-                    angle = D_800AD630[(var_s1 + sp6a + 1) % 8];
-                    prim->b1 = (((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp66);
-                    prim->r2 = prim->g2 = prim->b2 = prim->r3 = prim->g3 = prim->b3 = 0;
-                    D_800AD630[var_s1] += self->ext.playerBlink.unk8A;
+                angleRedIndex = dataPtr[0];
+                angleGreenIndex = dataPtr[2];
+                angleBlueIndex = dataPtr[1];
+                redDivide = dataPtr[4];
+                greenDivide = dataPtr[6];
+                blueDivide = dataPtr[5];
+                if (upperParams & 0x40) {
+                    angle = D_800AD630[(i + angleRedIndex) % 8];
+                    prim->r0 = ((rsin(angle) + 0x1000) >> 6) *
+                               self->ext.playerBlink.colorIntensity / redDivide;
+                    angle = D_800AD630[(i + angleGreenIndex) % 8];
+                    prim->g0 =
+                        ((rsin(angle) + 0x1000) >> 6) *
+                        self->ext.playerBlink.colorIntensity / greenDivide;
+                    angle = D_800AD630[(i + angleBlueIndex) % 8];
+                    prim->b0 =
+                        ((rsin(angle) + 0x1000) >> 6) *
+                        self->ext.playerBlink.colorIntensity / blueDivide;
+                    angle = D_800AD630[(i + angleRedIndex + 1) % 8];
+                    prim->r1 = ((rsin(angle) + 0x1000) >> 6) *
+                               self->ext.playerBlink.colorIntensity / redDivide;
+                    angle = D_800AD630[(i + angleGreenIndex + 1) % 8];
+                    prim->g1 =
+                        ((rsin(angle) + 0x1000) >> 6) *
+                        self->ext.playerBlink.colorIntensity / greenDivide;
+                    angle = D_800AD630[(i + angleBlueIndex + 1) % 8];
+                    prim->b1 =
+                        ((rsin(angle) + 0x1000) >> 6) *
+                        self->ext.playerBlink.colorIntensity / blueDivide;
+                    prim->r2 = prim->g2 = prim->b2 = prim->r3 = prim->g3 =
+                        prim->b3 = 0;
+                    D_800AD630[i] += self->ext.playerBlink.unk8A;
                 } else {
-                    angle = D_800AD630[(var_s1 + sp6e) % 8];
-                    prim->r0 = prim->r1 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp68);
-                    angle = D_800AD630[(var_s1 + sp6c) % 8];
-                    prim->g0 = prim->g1 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp64);
-                    angle = D_800AD630[(var_s1 + sp6a) % 8];
-                    prim->b0 = prim->b1 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp66);
-                    angle = D_800AD630[(var_s1 + sp6e + 1) % 8];
-                    prim->r2 = prim->r3 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp68);
-                    angle = D_800AD630[(var_s1 + sp6c + 1) % 8];
-                    prim->g2 = prim->g3 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp64);
-                    angle = D_800AD630[(var_s1 + sp6a + 1) % 8];
-                    prim->b2 = prim->b3 =(((rsin(angle) + 0x1000) >> 6) * self->ext.playerBlink.unk90 / sp66);
-                    D_800AD630[var_s1] += self->ext.playerBlink.unk8A;
+                    angle = D_800AD630[(i + angleRedIndex) % 8];
+                    prim->r0 = prim->r1 =
+                        ((rsin(angle) + 0x1000) >> 6) *
+                        self->ext.playerBlink.colorIntensity / redDivide;
+                    angle = D_800AD630[(i + angleGreenIndex) % 8];
+                    prim->g0 = prim->g1 =
+                        ((rsin(angle) + 0x1000) >> 6) *
+                        self->ext.playerBlink.colorIntensity / greenDivide;
+                    angle = D_800AD630[(i + angleBlueIndex) % 8];
+                    prim->b0 = prim->b1 =
+                        ((rsin(angle) + 0x1000) >> 6) *
+                        self->ext.playerBlink.colorIntensity / blueDivide;
+                    angle = D_800AD630[(i + angleRedIndex + 1) % 8];
+                    prim->r2 = prim->r3 =
+                        ((rsin(angle) + 0x1000) >> 6) *
+                        self->ext.playerBlink.colorIntensity / redDivide;
+                    angle = D_800AD630[(i + angleGreenIndex + 1) % 8];
+                    prim->g2 = prim->g3 =
+                        ((rsin(angle) + 0x1000) >> 6) *
+                        self->ext.playerBlink.colorIntensity / greenDivide;
+                    angle = D_800AD630[(i + angleBlueIndex + 1) % 8];
+                    prim->b2 = prim->b3 =
+                        ((rsin(angle) + 0x1000) >> 6) *
+                        self->ext.playerBlink.colorIntensity / blueDivide;
+                    D_800AD630[i] += self->ext.playerBlink.unk8A;
                 }
-                // clang-format on
             }
         }
         prim = prim->next;
     }
     func_8010DFF0(1, 1);
-    if (((sp70 & 0x3F) == 0) || ((sp70 & 0x3F) == 7)) {
+    if (((upperParams & 0x3F) == 0) || ((upperParams & 0x3F) == 7)) {
+        // set invincibility frames
         func_8010E168(1, 0xA);
     }
     return;
 
-block_229:
+set_unk6C_unk6E_0:
     g_Player.unk6C = g_Player.unk6E = 0;
-block_231:
+destroy_entity:
     DestroyEntity(self);
 }
 
diff --git a/src/maria/pl_blueprints.c b/src/maria/pl_blueprints.c
index 425253b6ce..58afbe48ee 100644
--- a/src/maria/pl_blueprints.c
+++ b/src/maria/pl_blueprints.c
@@ -1559,13 +1559,13 @@ void MarEntityPlayerBlinkWhite(Entity* self) {
             prim = prim->next;
         }
         self->ext.playerBlink.unk8A = dataPtr[9];
-        self->ext.playerBlink.unk90 = 0;
+        self->ext.playerBlink.colorIntensity = 0;
         self->step += 1;
         break;
     case 1:
-        self->ext.playerBlink.unk90 += 0xA;
-        if (self->ext.playerBlink.unk90 > 0x100) {
-            self->ext.playerBlink.unk90 = 0x100;
+        self->ext.playerBlink.colorIntensity += 0xA;
+        if (self->ext.playerBlink.colorIntensity > 0x100) {
+            self->ext.playerBlink.colorIntensity = 0x100;
             self->ext.playerBlink.unk80 = dataPtr[7];
             self->step += 1;
         }
@@ -1607,8 +1607,8 @@ void MarEntityPlayerBlinkWhite(Entity* self) {
         }
         break;
     case 3:
-        self->ext.playerBlink.unk90 -= 10;
-        if (self->ext.playerBlink.unk90 < 0) {
+        self->ext.playerBlink.colorIntensity -= 10;
+        if (self->ext.playerBlink.colorIntensity < 0) {
             DestroyEntity(self);
             return;
         }
@@ -1782,43 +1782,49 @@ void MarEntityPlayerBlinkWhite(Entity* self) {
         if (upperParams & 0x40) {
             angle = D_80154F7C[(i + angleRedIndex) % 8];
             prim->r0 = ((rsin(angle) + 0x1000) >> 6) *
-                       self->ext.playerBlink.unk90 / redDivide;
+                       self->ext.playerBlink.colorIntensity / redDivide;
             angle = D_80154F7C[(i + angleGreenIndex) % 8];
             prim->g0 = ((rsin(angle) + 0x1000) >> 6) *
-                       self->ext.playerBlink.unk90 / greenDivide;
+                       self->ext.playerBlink.colorIntensity / greenDivide;
             angle = D_80154F7C[(i + angleBlueIndex) % 8];
             prim->b0 = ((rsin(angle) + 0x1000) >> 6) *
-                       self->ext.playerBlink.unk90 / blueDivide;
+                       self->ext.playerBlink.colorIntensity / blueDivide;
             angle = D_80154F7C[(i + angleRedIndex + 1) % 8];
             prim->r1 = ((rsin(angle) + 0x1000) >> 6) *
-                       self->ext.playerBlink.unk90 / redDivide;
+                       self->ext.playerBlink.colorIntensity / redDivide;
             angle = D_80154F7C[(i + angleGreenIndex + 1) % 8];
             prim->g1 = ((rsin(angle) + 0x1000) >> 6) *
-                       self->ext.playerBlink.unk90 / greenDivide;
+                       self->ext.playerBlink.colorIntensity / greenDivide;
             angle = D_80154F7C[(i + angleBlueIndex + 1) % 8];
             prim->b1 = ((rsin(angle) + 0x1000) >> 6) *
-                       self->ext.playerBlink.unk90 / blueDivide;
+                       self->ext.playerBlink.colorIntensity / blueDivide;
             prim->r2 = prim->g2 = prim->b2 = prim->r3 = prim->g3 = prim->b3 = 0;
             D_80154F7C[i] += self->ext.playerBlink.unk8A;
         } else {
             angle = D_80154F7C[(i + angleRedIndex) % 8];
-            prim->r0 = prim->r1 = (((rsin(angle) + 0x1000) >> 6) *
-                                   self->ext.playerBlink.unk90 / redDivide);
+            prim->r0 = prim->r1 =
+                (((rsin(angle) + 0x1000) >> 6) *
+                 self->ext.playerBlink.colorIntensity / redDivide);
             angle = D_80154F7C[(i + angleGreenIndex) % 8];
-            prim->g0 = prim->g1 = (((rsin(angle) + 0x1000) >> 6) *
-                                   self->ext.playerBlink.unk90 / greenDivide);
+            prim->g0 = prim->g1 =
+                (((rsin(angle) + 0x1000) >> 6) *
+                 self->ext.playerBlink.colorIntensity / greenDivide);
             angle = D_80154F7C[(i + angleBlueIndex) % 8];
-            prim->b0 = prim->b1 = (((rsin(angle) + 0x1000) >> 6) *
-                                   self->ext.playerBlink.unk90 / blueDivide);
+            prim->b0 = prim->b1 =
+                (((rsin(angle) + 0x1000) >> 6) *
+                 self->ext.playerBlink.colorIntensity / blueDivide);
             angle = D_80154F7C[(i + angleRedIndex + 1) % 8];
-            prim->r2 = prim->r3 = (((rsin(angle) + 0x1000) >> 6) *
-                                   self->ext.playerBlink.unk90 / redDivide);
+            prim->r2 = prim->r3 =
+                (((rsin(angle) + 0x1000) >> 6) *
+                 self->ext.playerBlink.colorIntensity / redDivide);
             angle = D_80154F7C[(i + angleGreenIndex + 1) % 8];
-            prim->g2 = prim->g3 = (((rsin(angle) + 0x1000) >> 6) *
-                                   self->ext.playerBlink.unk90 / greenDivide);
+            prim->g2 = prim->g3 =
+                (((rsin(angle) + 0x1000) >> 6) *
+                 self->ext.playerBlink.colorIntensity / greenDivide);
             angle = D_80154F7C[(i + angleBlueIndex + 1) % 8];
-            prim->b2 = prim->b3 = (((rsin(angle) + 0x1000) >> 6) *
-                                   self->ext.playerBlink.unk90 / blueDivide);
+            prim->b2 = prim->b3 =
+                (((rsin(angle) + 0x1000) >> 6) *
+                 self->ext.playerBlink.colorIntensity / blueDivide);
             D_80154F7C[i] += self->ext.playerBlink.unk8A;
         }
         prim->priority = PLAYER.zPriority + 2;
diff --git a/src/ric/pl_blueprints.c b/src/ric/pl_blueprints.c
index 14e5603cee..bad80df341 100644
--- a/src/ric/pl_blueprints.c
+++ b/src/ric/pl_blueprints.c
@@ -1836,13 +1836,13 @@ void RicEntityPlayerBlinkWhite(Entity* self) {
             prim = prim->next;
         }
         self->ext.playerBlink.unk8A = dataPtr[9];
-        self->ext.playerBlink.unk90 = 0;
+        self->ext.playerBlink.colorIntensity = 0;
         self->step += 1;
         break;
     case 1:
-        self->ext.playerBlink.unk90 += 0xA;
-        if (self->ext.playerBlink.unk90 > 0x100) {
-            self->ext.playerBlink.unk90 = 0x100;
+        self->ext.playerBlink.colorIntensity += 0xA;
+        if (self->ext.playerBlink.colorIntensity > 0x100) {
+            self->ext.playerBlink.colorIntensity = 0x100;
             self->ext.playerBlink.unk80 = dataPtr[7];
             self->step += 1;
         }
@@ -1884,8 +1884,8 @@ void RicEntityPlayerBlinkWhite(Entity* self) {
         }
         break;
     case 3:
-        self->ext.playerBlink.unk90 -= 10;
-        if (self->ext.playerBlink.unk90 < 0) {
+        self->ext.playerBlink.colorIntensity -= 10;
+        if (self->ext.playerBlink.colorIntensity < 0) {
             DestroyEntity(self);
             return;
         }
@@ -2059,43 +2059,49 @@ void RicEntityPlayerBlinkWhite(Entity* self) {
         if (upperParams & 0x40) {
             angle = D_80154F7C[(i + angleRedIndex) % 8];
             prim->r0 = ((rsin(angle) + 0x1000) >> 6) *
-                       self->ext.playerBlink.unk90 / redDivide;
+                       self->ext.playerBlink.colorIntensity / redDivide;
             angle = D_80154F7C[(i + angleGreenIndex) % 8];
             prim->g0 = ((rsin(angle) + 0x1000) >> 6) *
-                       self->ext.playerBlink.unk90 / greenDivide;
+                       self->ext.playerBlink.colorIntensity / greenDivide;
             angle = D_80154F7C[(i + angleBlueIndex) % 8];
             prim->b0 = ((rsin(angle) + 0x1000) >> 6) *
-                       self->ext.playerBlink.unk90 / blueDivide;
+                       self->ext.playerBlink.colorIntensity / blueDivide;
             angle = D_80154F7C[(i + angleRedIndex + 1) % 8];
             prim->r1 = ((rsin(angle) + 0x1000) >> 6) *
-                       self->ext.playerBlink.unk90 / redDivide;
+                       self->ext.playerBlink.colorIntensity / redDivide;
             angle = D_80154F7C[(i + angleGreenIndex + 1) % 8];
             prim->g1 = ((rsin(angle) + 0x1000) >> 6) *
-                       self->ext.playerBlink.unk90 / greenDivide;
+                       self->ext.playerBlink.colorIntensity / greenDivide;
             angle = D_80154F7C[(i + angleBlueIndex + 1) % 8];
             prim->b1 = ((rsin(angle) + 0x1000) >> 6) *
-                       self->ext.playerBlink.unk90 / blueDivide;
+                       self->ext.playerBlink.colorIntensity / blueDivide;
             prim->r2 = prim->g2 = prim->b2 = prim->r3 = prim->g3 = prim->b3 = 0;
             D_80154F7C[i] += self->ext.playerBlink.unk8A;
         } else {
             angle = D_80154F7C[(i + angleRedIndex) % 8];
-            prim->r0 = prim->r1 = (((rsin(angle) + 0x1000) >> 6) *
-                                   self->ext.playerBlink.unk90 / redDivide);
+            prim->r0 = prim->r1 =
+                (((rsin(angle) + 0x1000) >> 6) *
+                 self->ext.playerBlink.colorIntensity / redDivide);
             angle = D_80154F7C[(i + angleGreenIndex) % 8];
-            prim->g0 = prim->g1 = (((rsin(angle) + 0x1000) >> 6) *
-                                   self->ext.playerBlink.unk90 / greenDivide);
+            prim->g0 = prim->g1 =
+                (((rsin(angle) + 0x1000) >> 6) *
+                 self->ext.playerBlink.colorIntensity / greenDivide);
             angle = D_80154F7C[(i + angleBlueIndex) % 8];
-            prim->b0 = prim->b1 = (((rsin(angle) + 0x1000) >> 6) *
-                                   self->ext.playerBlink.unk90 / blueDivide);
+            prim->b0 = prim->b1 =
+                (((rsin(angle) + 0x1000) >> 6) *
+                 self->ext.playerBlink.colorIntensity / blueDivide);
             angle = D_80154F7C[(i + angleRedIndex + 1) % 8];
-            prim->r2 = prim->r3 = (((rsin(angle) + 0x1000) >> 6) *
-                                   self->ext.playerBlink.unk90 / redDivide);
+            prim->r2 = prim->r3 =
+                (((rsin(angle) + 0x1000) >> 6) *
+                 self->ext.playerBlink.colorIntensity / redDivide);
             angle = D_80154F7C[(i + angleGreenIndex + 1) % 8];
-            prim->g2 = prim->g3 = (((rsin(angle) + 0x1000) >> 6) *
-                                   self->ext.playerBlink.unk90 / greenDivide);
+            prim->g2 = prim->g3 =
+                (((rsin(angle) + 0x1000) >> 6) *
+                 self->ext.playerBlink.colorIntensity / greenDivide);
             angle = D_80154F7C[(i + angleBlueIndex + 1) % 8];
-            prim->b2 = prim->b3 = (((rsin(angle) + 0x1000) >> 6) *
-                                   self->ext.playerBlink.unk90 / blueDivide);
+            prim->b2 = prim->b3 =
+                (((rsin(angle) + 0x1000) >> 6) *
+                 self->ext.playerBlink.colorIntensity / blueDivide);
             D_80154F7C[i] += self->ext.playerBlink.unk8A;
         }
         prim->priority = PLAYER.zPriority + 2;