JKRDvdRipper, JKRSolidHeap (#199)

17 files changed, 491 insertions, 498 deletions

diff --git a/asm/JSystem/JKernel/JKRDvdRipper/firstSrcData__Fv.s b/asm/JSystem/JKernel/JKRDvdRipper/firstSrcData__Fv.s
deleted file mode 100644
index 92227dd3b0..0000000000
--- a/asm/JSystem/JKernel/JKRDvdRipper/firstSrcData__Fv.s
+++ /dev/null
@@ -1,58 +0,0 @@
-lbl_802DA60C:
-/* 802DA60C  94 21 FF E0 */	stwu r1, -0x20(r1)
-/* 802DA610  7C 08 02 A6 */	mflr r0
-/* 802DA614  90 01 00 24 */	stw r0, 0x24(r1)
-/* 802DA618  39 61 00 20 */	addi r11, r1, 0x20
-/* 802DA61C  48 08 7B C1 */	bl _savegpr_29
-/* 802DA620  80 6D 8E AC */	lwz r3, szpEnd(r13)
-/* 802DA624  38 03 FF E7 */	addi r0, r3, -25
-/* 802DA628  90 0D 8E C4 */	stw r0, srcLimit(r13)
-/* 802DA62C  80 0D 8E A8 */	lwz r0, szpBuf(r13)
-/* 802DA630  7C 1D 03 78 */	mr r29, r0
-/* 802DA634  7C 60 18 50 */	subf r3, r0, r3
-/* 802DA638  80 0D 8E C0 */	lwz r0, transLeft(r13)
-/* 802DA63C  7C 00 18 40 */	cmplw r0, r3
-/* 802DA640  7C 7F 1B 78 */	mr r31, r3
-/* 802DA644  40 80 00 08 */	bge lbl_802DA64C
-/* 802DA648  7C 1F 03 78 */	mr r31, r0
-lbl_802DA64C:
-/* 802DA64C  7F FE FB 78 */	mr r30, r31
-lbl_802DA650:
-/* 802DA650  80 6D 8E C8 */	lwz r3, srcFile(r13)
-/* 802DA654  38 63 00 5C */	addi r3, r3, 0x5c
-/* 802DA658  7F A4 EB 78 */	mr r4, r29
-/* 802DA65C  7F C5 F3 78 */	mr r5, r30
-/* 802DA660  80 CD 8E BC */	lwz r6, srcOffset(r13)
-/* 802DA664  38 E0 00 02 */	li r7, 2
-/* 802DA668  48 06 E7 DD */	bl DVDReadPrio
-/* 802DA66C  2C 03 00 00 */	cmpwi r3, 0
-/* 802DA670  40 80 00 28 */	bge lbl_802DA698
-/* 802DA674  2C 03 FF FD */	cmpwi r3, -3
-/* 802DA678  41 82 00 10 */	beq lbl_802DA688
-/* 802DA67C  88 0D 83 48 */	lbz r0, data_804508C8(r13)
-/* 802DA680  28 00 00 00 */	cmplwi r0, 0
-/* 802DA684  40 82 00 0C */	bne lbl_802DA690
-lbl_802DA688:
-/* 802DA688  38 60 00 00 */	li r3, 0
-/* 802DA68C  48 00 00 34 */	b lbl_802DA6C0
-lbl_802DA690:
-/* 802DA690  48 07 23 35 */	bl VIWaitForRetrace
-/* 802DA694  4B FF FF BC */	b lbl_802DA650
-lbl_802DA698:
-/* 802DA698  7F A3 EB 78 */	mr r3, r29
-/* 802DA69C  7F E4 FB 78 */	mr r4, r31
-/* 802DA6A0  48 06 0E E1 */	bl DCInvalidateRange
-/* 802DA6A4  80 0D 8E BC */	lwz r0, srcOffset(r13)
-/* 802DA6A8  7C 00 FA 14 */	add r0, r0, r31
-/* 802DA6AC  90 0D 8E BC */	stw r0, srcOffset(r13)
-/* 802DA6B0  80 0D 8E C0 */	lwz r0, transLeft(r13)
-/* 802DA6B4  7C 1F 00 50 */	subf r0, r31, r0
-/* 802DA6B8  90 0D 8E C0 */	stw r0, transLeft(r13)
-/* 802DA6BC  7F A3 EB 78 */	mr r3, r29
-lbl_802DA6C0:
-/* 802DA6C0  39 61 00 20 */	addi r11, r1, 0x20
-/* 802DA6C4  48 08 7B 65 */	bl _restgpr_29
-/* 802DA6C8  80 01 00 24 */	lwz r0, 0x24(r1)
-/* 802DA6CC  7C 08 03 A6 */	mtlr r0
-/* 802DA6D0  38 21 00 20 */	addi r1, r1, 0x20
-/* 802DA6D4  4E 80 00 20 */	blr 
diff --git a/asm/JSystem/JKernel/JKRDvdRipper/func_802D9B98.s b/asm/JSystem/JKernel/JKRDvdRipper/func_802D9B98.s
deleted file mode 100644
index e07631e39c..0000000000
--- a/asm/JSystem/JKernel/JKRDvdRipper/func_802D9B98.s
+++ /dev/null
@@ -1,50 +0,0 @@
-lbl_802D9B98:
-/* 802D9B98  94 21 FE D0 */	stwu r1, -0x130(r1)
-/* 802D9B9C  7C 08 02 A6 */	mflr r0
-/* 802D9BA0  90 01 01 34 */	stw r0, 0x134(r1)
-/* 802D9BA4  39 61 01 30 */	addi r11, r1, 0x130
-/* 802D9BA8  48 08 86 1D */	bl _savegpr_23
-/* 802D9BAC  7C 77 1B 78 */	mr r23, r3
-/* 802D9BB0  7C 98 23 78 */	mr r24, r4
-/* 802D9BB4  7C B9 2B 78 */	mr r25, r5
-/* 802D9BB8  7C DA 33 78 */	mr r26, r6
-/* 802D9BBC  7C FB 3B 78 */	mr r27, r7
-/* 802D9BC0  7D 1C 43 78 */	mr r28, r8
-/* 802D9BC4  7D 3D 4B 78 */	mr r29, r9
-/* 802D9BC8  7D 5E 53 78 */	mr r30, r10
-/* 802D9BCC  83 E1 01 38 */	lwz r31, 0x138(r1)
-/* 802D9BD0  38 61 00 10 */	addi r3, r1, 0x10
-/* 802D9BD4  4B FF F9 B1 */	bl __ct__10JKRDvdFileFv
-/* 802D9BD8  38 61 00 10 */	addi r3, r1, 0x10
-/* 802D9BDC  7E E4 BB 78 */	mr r4, r23
-/* 802D9BE0  4B FF FC 71 */	bl open__10JKRDvdFileFPCc
-/* 802D9BE4  54 60 06 3F */	clrlwi. r0, r3, 0x18
-/* 802D9BE8  40 82 00 18 */	bne lbl_802D9C00
-/* 802D9BEC  38 61 00 10 */	addi r3, r1, 0x10
-/* 802D9BF0  38 80 FF FF */	li r4, -1
-/* 802D9BF4  4B FF FB 55 */	bl __dt__10JKRDvdFileFv
-/* 802D9BF8  38 60 00 00 */	li r3, 0
-/* 802D9BFC  48 00 00 40 */	b lbl_802D9C3C
-lbl_802D9C00:
-/* 802D9C00  93 E1 00 08 */	stw r31, 8(r1)
-/* 802D9C04  38 61 00 10 */	addi r3, r1, 0x10
-/* 802D9C08  7F 04 C3 78 */	mr r4, r24
-/* 802D9C0C  7F 25 CB 78 */	mr r5, r25
-/* 802D9C10  7F 46 D3 78 */	mr r6, r26
-/* 802D9C14  7F 67 DB 78 */	mr r7, r27
-/* 802D9C18  7F 88 E3 78 */	mr r8, r28
-/* 802D9C1C  7F A9 EB 78 */	mr r9, r29
-/* 802D9C20  7F CA F3 78 */	mr r10, r30
-/* 802D9C24  48 00 00 ED */	bl loadToMainRAM__12JKRDvdRipperFP10JKRDvdFilePUc15JKRExpandSwitchUlP7JKRHeapQ212JKRDvdRipper15EAllocDirectionUlPiPUl
-/* 802D9C28  7C 7F 1B 78 */	mr r31, r3
-/* 802D9C2C  38 61 00 10 */	addi r3, r1, 0x10
-/* 802D9C30  38 80 FF FF */	li r4, -1
-/* 802D9C34  4B FF FB 15 */	bl __dt__10JKRDvdFileFv
-/* 802D9C38  7F E3 FB 78 */	mr r3, r31
-lbl_802D9C3C:
-/* 802D9C3C  39 61 01 30 */	addi r11, r1, 0x130
-/* 802D9C40  48 08 85 D1 */	bl _restgpr_23
-/* 802D9C44  80 01 01 34 */	lwz r0, 0x134(r1)
-/* 802D9C48  7C 08 03 A6 */	mtlr r0
-/* 802D9C4C  38 21 01 30 */	addi r1, r1, 0x130
-/* 802D9C50  4E 80 00 20 */	blr 
diff --git a/asm/JSystem/JKernel/JKRDvdRipper/func_802D9C54.s b/asm/JSystem/JKernel/JKRDvdRipper/func_802D9C54.s
deleted file mode 100644
index 301e572c8c..0000000000
--- a/asm/JSystem/JKernel/JKRDvdRipper/func_802D9C54.s
+++ /dev/null
@@ -1,50 +0,0 @@
-lbl_802D9C54:
-/* 802D9C54  94 21 FE D0 */	stwu r1, -0x130(r1)
-/* 802D9C58  7C 08 02 A6 */	mflr r0
-/* 802D9C5C  90 01 01 34 */	stw r0, 0x134(r1)
-/* 802D9C60  39 61 01 30 */	addi r11, r1, 0x130
-/* 802D9C64  48 08 85 61 */	bl _savegpr_23
-/* 802D9C68  7C 77 1B 78 */	mr r23, r3
-/* 802D9C6C  7C 98 23 78 */	mr r24, r4
-/* 802D9C70  7C B9 2B 78 */	mr r25, r5
-/* 802D9C74  7C DA 33 78 */	mr r26, r6
-/* 802D9C78  7C FB 3B 78 */	mr r27, r7
-/* 802D9C7C  7D 1C 43 78 */	mr r28, r8
-/* 802D9C80  7D 3D 4B 78 */	mr r29, r9
-/* 802D9C84  7D 5E 53 78 */	mr r30, r10
-/* 802D9C88  83 E1 01 38 */	lwz r31, 0x138(r1)
-/* 802D9C8C  38 61 00 10 */	addi r3, r1, 0x10
-/* 802D9C90  4B FF F8 F5 */	bl __ct__10JKRDvdFileFv
-/* 802D9C94  38 61 00 10 */	addi r3, r1, 0x10
-/* 802D9C98  7E E4 BB 78 */	mr r4, r23
-/* 802D9C9C  4B FF FC 29 */	bl open__10JKRDvdFileFl
-/* 802D9CA0  54 60 06 3F */	clrlwi. r0, r3, 0x18
-/* 802D9CA4  40 82 00 18 */	bne lbl_802D9CBC
-/* 802D9CA8  38 61 00 10 */	addi r3, r1, 0x10
-/* 802D9CAC  38 80 FF FF */	li r4, -1
-/* 802D9CB0  4B FF FA 99 */	bl __dt__10JKRDvdFileFv
-/* 802D9CB4  38 60 00 00 */	li r3, 0
-/* 802D9CB8  48 00 00 40 */	b lbl_802D9CF8
-lbl_802D9CBC:
-/* 802D9CBC  93 E1 00 08 */	stw r31, 8(r1)
-/* 802D9CC0  38 61 00 10 */	addi r3, r1, 0x10
-/* 802D9CC4  7F 04 C3 78 */	mr r4, r24
-/* 802D9CC8  7F 25 CB 78 */	mr r5, r25
-/* 802D9CCC  7F 46 D3 78 */	mr r6, r26
-/* 802D9CD0  7F 67 DB 78 */	mr r7, r27
-/* 802D9CD4  7F 88 E3 78 */	mr r8, r28
-/* 802D9CD8  7F A9 EB 78 */	mr r9, r29
-/* 802D9CDC  7F CA F3 78 */	mr r10, r30
-/* 802D9CE0  48 00 00 31 */	bl loadToMainRAM__12JKRDvdRipperFP10JKRDvdFilePUc15JKRExpandSwitchUlP7JKRHeapQ212JKRDvdRipper15EAllocDirectionUlPiPUl
-/* 802D9CE4  7C 7F 1B 78 */	mr r31, r3
-/* 802D9CE8  38 61 00 10 */	addi r3, r1, 0x10
-/* 802D9CEC  38 80 FF FF */	li r4, -1
-/* 802D9CF0  4B FF FA 59 */	bl __dt__10JKRDvdFileFv
-/* 802D9CF4  7F E3 FB 78 */	mr r3, r31
-lbl_802D9CF8:
-/* 802D9CF8  39 61 01 30 */	addi r11, r1, 0x130
-/* 802D9CFC  48 08 85 15 */	bl _restgpr_23
-/* 802D9D00  80 01 01 34 */	lwz r0, 0x134(r1)
-/* 802D9D04  7C 08 03 A6 */	mtlr r0
-/* 802D9D08  38 21 01 30 */	addi r1, r1, 0x130
-/* 802D9D0C  4E 80 00 20 */	blr 
diff --git a/asm/JSystem/JKernel/JKRSolidHeap/adjustSize__12JKRSolidHeapFv.s b/asm/JSystem/JKernel/JKRSolidHeap/adjustSize__12JKRSolidHeapFv.s
deleted file mode 100644
index 36497627a3..0000000000
--- a/asm/JSystem/JKernel/JKRSolidHeap/adjustSize__12JKRSolidHeapFv.s
+++ /dev/null
@@ -1,51 +0,0 @@
-lbl_802D0BF4:
-/* 802D0BF4  94 21 FF E0 */	stwu r1, -0x20(r1)
-/* 802D0BF8  7C 08 02 A6 */	mflr r0
-/* 802D0BFC  90 01 00 24 */	stw r0, 0x24(r1)
-/* 802D0C00  39 61 00 20 */	addi r11, r1, 0x20
-/* 802D0C04  48 09 15 D9 */	bl _savegpr_29
-/* 802D0C08  7C 7D 1B 78 */	mr r29, r3
-/* 802D0C0C  80 63 00 50 */	lwz r3, 0x50(r3)
-/* 802D0C10  83 E3 00 0C */	lwz r31, 0xc(r3)
-/* 802D0C14  28 1F 00 00 */	cmplwi r31, 0
-/* 802D0C18  41 82 00 7C */	beq lbl_802D0C94
-/* 802D0C1C  38 7D 00 18 */	addi r3, r29, 0x18
-/* 802D0C20  48 06 E4 21 */	bl OSLockMutex
-/* 802D0C24  80 7D 00 30 */	lwz r3, 0x30(r29)
-/* 802D0C28  7C BD 18 50 */	subf r5, r29, r3
-/* 802D0C2C  80 1D 00 70 */	lwz r0, 0x70(r29)
-/* 802D0C30  7C 63 00 50 */	subf r3, r3, r0
-/* 802D0C34  38 03 00 1F */	addi r0, r3, 0x1f
-/* 802D0C38  54 1E 00 34 */	rlwinm r30, r0, 0, 0, 0x1a
-/* 802D0C3C  7F E3 FB 78 */	mr r3, r31
-/* 802D0C40  7F A4 EB 78 */	mr r4, r29
-/* 802D0C44  7F E5 F2 14 */	add r31, r5, r30
-/* 802D0C48  7F E5 FB 78 */	mr r5, r31
-/* 802D0C4C  4B FF DA 39 */	bl resize__7JKRHeapFPvUl
-/* 802D0C50  2C 03 FF FF */	cmpwi r3, -1
-/* 802D0C54  41 82 00 30 */	beq lbl_802D0C84
-/* 802D0C58  38 00 00 00 */	li r0, 0
-/* 802D0C5C  90 1D 00 6C */	stw r0, 0x6c(r29)
-/* 802D0C60  93 DD 00 38 */	stw r30, 0x38(r29)
-/* 802D0C64  80 7D 00 30 */	lwz r3, 0x30(r29)
-/* 802D0C68  80 1D 00 38 */	lwz r0, 0x38(r29)
-/* 802D0C6C  7C 03 02 14 */	add r0, r3, r0
-/* 802D0C70  90 1D 00 34 */	stw r0, 0x34(r29)
-/* 802D0C74  80 1D 00 34 */	lwz r0, 0x34(r29)
-/* 802D0C78  90 1D 00 70 */	stw r0, 0x70(r29)
-/* 802D0C7C  80 1D 00 34 */	lwz r0, 0x34(r29)
-/* 802D0C80  90 1D 00 74 */	stw r0, 0x74(r29)
-lbl_802D0C84:
-/* 802D0C84  38 7D 00 18 */	addi r3, r29, 0x18
-/* 802D0C88  48 06 E4 95 */	bl OSUnlockMutex
-/* 802D0C8C  7F E3 FB 78 */	mr r3, r31
-/* 802D0C90  48 00 00 08 */	b lbl_802D0C98
-lbl_802D0C94:
-/* 802D0C94  38 60 FF FF */	li r3, -1
-lbl_802D0C98:
-/* 802D0C98  39 61 00 20 */	addi r11, r1, 0x20
-/* 802D0C9C  48 09 15 8D */	bl _restgpr_29
-/* 802D0CA0  80 01 00 24 */	lwz r0, 0x24(r1)
-/* 802D0CA4  7C 08 03 A6 */	mtlr r0
-/* 802D0CA8  38 21 00 20 */	addi r1, r1, 0x20
-/* 802D0CAC  4E 80 00 20 */	blr 
diff --git a/asm/JSystem/JKernel/JKRSolidHeap/allocFromHead__12JKRSolidHeapFUli.s b/asm/JSystem/JKernel/JKRSolidHeap/allocFromHead__12JKRSolidHeapFUli.s
deleted file mode 100644
index 917109829d..0000000000
--- a/asm/JSystem/JKernel/JKRSolidHeap/allocFromHead__12JKRSolidHeapFUli.s
+++ /dev/null
@@ -1,53 +0,0 @@
-lbl_802D0D58:
-/* 802D0D58  94 21 FF E0 */	stwu r1, -0x20(r1)
-/* 802D0D5C  7C 08 02 A6 */	mflr r0
-/* 802D0D60  90 01 00 24 */	stw r0, 0x24(r1)
-/* 802D0D64  39 61 00 20 */	addi r11, r1, 0x20
-/* 802D0D68  48 09 14 71 */	bl _savegpr_28
-/* 802D0D6C  7C 7F 1B 78 */	mr r31, r3
-/* 802D0D70  7C BD 2B 78 */	mr r29, r5
-/* 802D0D74  38 04 00 03 */	addi r0, r4, 3
-/* 802D0D78  54 1C 00 3A */	rlwinm r28, r0, 0, 0, 0x1d
-/* 802D0D7C  3B C0 00 00 */	li r30, 0
-/* 802D0D80  38 1D FF FF */	addi r0, r29, -1
-/* 802D0D84  7C 04 00 F8 */	nor r4, r0, r0
-/* 802D0D88  80 A3 00 70 */	lwz r5, 0x70(r3)
-/* 802D0D8C  7C 7D 2A 14 */	add r3, r29, r5
-/* 802D0D90  38 03 FF FF */	addi r0, r3, -1
-/* 802D0D94  7C 83 00 38 */	and r3, r4, r0
-/* 802D0D98  7C 05 18 50 */	subf r0, r5, r3
-/* 802D0D9C  7C 9C 02 14 */	add r4, r28, r0
-/* 802D0DA0  80 1F 00 6C */	lwz r0, 0x6c(r31)
-/* 802D0DA4  7C 04 00 40 */	cmplw r4, r0
-/* 802D0DA8  41 81 00 20 */	bgt lbl_802D0DC8
-/* 802D0DAC  7C 7E 1B 78 */	mr r30, r3
-/* 802D0DB0  7C 05 22 14 */	add r0, r5, r4
-/* 802D0DB4  90 1F 00 70 */	stw r0, 0x70(r31)
-/* 802D0DB8  80 1F 00 6C */	lwz r0, 0x6c(r31)
-/* 802D0DBC  7C 04 00 50 */	subf r0, r4, r0
-/* 802D0DC0  90 1F 00 6C */	stw r0, 0x6c(r31)
-/* 802D0DC4  48 00 00 40 */	b lbl_802D0E04
-lbl_802D0DC8:
-/* 802D0DC8  3C 60 80 3A */	lis r3, JKRSolidHeap__stringBase0@ha /* 0x8039CE50@ha */
-/* 802D0DCC  38 63 CE 50 */	addi r3, r3, JKRSolidHeap__stringBase0@l /* 0x8039CE50@l */
-/* 802D0DD0  4C C6 31 82 */	crclr 6
-/* 802D0DD4  48 01 78 A9 */	bl JUTWarningConsole_f
-/* 802D0DD8  88 1F 00 68 */	lbz r0, 0x68(r31)
-/* 802D0DDC  28 00 00 01 */	cmplwi r0, 1
-/* 802D0DE0  40 82 00 24 */	bne lbl_802D0E04
-/* 802D0DE4  81 8D 8D FC */	lwz r12, mErrorHandler__7JKRHeap(r13)
-/* 802D0DE8  28 0C 00 00 */	cmplwi r12, 0
-/* 802D0DEC  41 82 00 18 */	beq lbl_802D0E04
-/* 802D0DF0  7F E3 FB 78 */	mr r3, r31
-/* 802D0DF4  7F 84 E3 78 */	mr r4, r28
-/* 802D0DF8  7F A5 EB 78 */	mr r5, r29
-/* 802D0DFC  7D 89 03 A6 */	mtctr r12
-/* 802D0E00  4E 80 04 21 */	bctrl 
-lbl_802D0E04:
-/* 802D0E04  7F C3 F3 78 */	mr r3, r30
-/* 802D0E08  39 61 00 20 */	addi r11, r1, 0x20
-/* 802D0E0C  48 09 14 19 */	bl _restgpr_28
-/* 802D0E10  80 01 00 24 */	lwz r0, 0x24(r1)
-/* 802D0E14  7C 08 03 A6 */	mtlr r0
-/* 802D0E18  38 21 00 20 */	addi r1, r1, 0x20
-/* 802D0E1C  4E 80 00 20 */	blr 
diff --git a/asm/JSystem/JKernel/JKRSolidHeap/allocFromTail__12JKRSolidHeapFUli.s b/asm/JSystem/JKernel/JKRSolidHeap/allocFromTail__12JKRSolidHeapFUli.s
deleted file mode 100644
index 5878d91bda..0000000000
--- a/asm/JSystem/JKernel/JKRSolidHeap/allocFromTail__12JKRSolidHeapFUli.s
+++ /dev/null
@@ -1,52 +0,0 @@
-lbl_802D0E20:
-/* 802D0E20  94 21 FF E0 */	stwu r1, -0x20(r1)
-/* 802D0E24  7C 08 02 A6 */	mflr r0
-/* 802D0E28  90 01 00 24 */	stw r0, 0x24(r1)
-/* 802D0E2C  39 61 00 20 */	addi r11, r1, 0x20
-/* 802D0E30  48 09 13 A9 */	bl _savegpr_28
-/* 802D0E34  7C 7F 1B 78 */	mr r31, r3
-/* 802D0E38  7C BD 2B 78 */	mr r29, r5
-/* 802D0E3C  38 04 00 03 */	addi r0, r4, 3
-/* 802D0E40  54 1C 00 3A */	rlwinm r28, r0, 0, 0, 0x1d
-/* 802D0E44  3B C0 00 00 */	li r30, 0
-/* 802D0E48  38 1D FF FF */	addi r0, r29, -1
-/* 802D0E4C  7C 03 00 F8 */	nor r3, r0, r0
-/* 802D0E50  80 BF 00 74 */	lwz r5, 0x74(r31)
-/* 802D0E54  7C 1C 28 50 */	subf r0, r28, r5
-/* 802D0E58  7C 63 00 38 */	and r3, r3, r0
-/* 802D0E5C  7C 83 28 50 */	subf r4, r3, r5
-/* 802D0E60  80 1F 00 6C */	lwz r0, 0x6c(r31)
-/* 802D0E64  7C 04 00 40 */	cmplw r4, r0
-/* 802D0E68  41 81 00 20 */	bgt lbl_802D0E88
-/* 802D0E6C  7C 7E 1B 78 */	mr r30, r3
-/* 802D0E70  7C 04 28 50 */	subf r0, r4, r5
-/* 802D0E74  90 1F 00 74 */	stw r0, 0x74(r31)
-/* 802D0E78  80 1F 00 6C */	lwz r0, 0x6c(r31)
-/* 802D0E7C  7C 04 00 50 */	subf r0, r4, r0
-/* 802D0E80  90 1F 00 6C */	stw r0, 0x6c(r31)
-/* 802D0E84  48 00 00 44 */	b lbl_802D0EC8
-lbl_802D0E88:
-/* 802D0E88  3C 60 80 3A */	lis r3, JKRSolidHeap__stringBase0@ha /* 0x8039CE50@ha */
-/* 802D0E8C  38 63 CE 50 */	addi r3, r3, JKRSolidHeap__stringBase0@l /* 0x8039CE50@l */
-/* 802D0E90  38 63 00 31 */	addi r3, r3, 0x31
-/* 802D0E94  4C C6 31 82 */	crclr 6
-/* 802D0E98  48 01 77 E5 */	bl JUTWarningConsole_f
-/* 802D0E9C  88 1F 00 68 */	lbz r0, 0x68(r31)
-/* 802D0EA0  28 00 00 01 */	cmplwi r0, 1
-/* 802D0EA4  40 82 00 24 */	bne lbl_802D0EC8
-/* 802D0EA8  81 8D 8D FC */	lwz r12, mErrorHandler__7JKRHeap(r13)
-/* 802D0EAC  28 0C 00 00 */	cmplwi r12, 0
-/* 802D0EB0  41 82 00 18 */	beq lbl_802D0EC8
-/* 802D0EB4  7F E3 FB 78 */	mr r3, r31
-/* 802D0EB8  7F 84 E3 78 */	mr r4, r28
-/* 802D0EBC  7F A5 EB 78 */	mr r5, r29
-/* 802D0EC0  7D 89 03 A6 */	mtctr r12
-/* 802D0EC4  4E 80 04 21 */	bctrl 
-lbl_802D0EC8:
-/* 802D0EC8  7F C3 F3 78 */	mr r3, r30
-/* 802D0ECC  39 61 00 20 */	addi r11, r1, 0x20
-/* 802D0ED0  48 09 13 55 */	bl _restgpr_28
-/* 802D0ED4  80 01 00 24 */	lwz r0, 0x24(r1)
-/* 802D0ED8  7C 08 03 A6 */	mtlr r0
-/* 802D0EDC  38 21 00 20 */	addi r1, r1, 0x20
-/* 802D0EE0  4E 80 00 20 */	blr 
diff --git a/asm/d/com/d_com_inf_game/dComLbG_PhaseHandler__FP30request_of_phase_process_classPPFPv_iPv.s b/asm/d/com/d_com_inf_game/dComLbG_PhaseHandler__FP30request_of_phase_process_classPPFPv_iPv.s
deleted file mode 100644
index e565f19a34..0000000000
--- a/asm/d/com/d_com_inf_game/dComLbG_PhaseHandler__FP30request_of_phase_process_classPPFPv_iPv.s
+++ /dev/null
@@ -1,27 +0,0 @@
-lbl_8002FB20:
-/* 8002FB20  94 21 FF E0 */	stwu r1, -0x20(r1)
-/* 8002FB24  7C 08 02 A6 */	mflr r0
-/* 8002FB28  90 01 00 24 */	stw r0, 0x24(r1)
-/* 8002FB2C  39 61 00 20 */	addi r11, r1, 0x20
-/* 8002FB30  48 33 26 AD */	bl _savegpr_29
-/* 8002FB34  7C 7D 1B 78 */	mr r29, r3
-/* 8002FB38  7C 9E 23 78 */	mr r30, r4
-/* 8002FB3C  7C BF 2B 78 */	mr r31, r5
-/* 8002FB40  48 23 6C 6D */	bl cPhs_Handler__FP30request_of_phase_process_classPPFPv_iPv
-/* 8002FB44  2C 03 00 02 */	cmpwi r3, 2
-/* 8002FB48  41 82 00 10 */	beq lbl_8002FB58
-/* 8002FB4C  40 80 00 1C */	bge lbl_8002FB68
-/* 8002FB50  48 00 00 18 */	b lbl_8002FB68
-/* 8002FB54  48 00 00 14 */	b lbl_8002FB68
-lbl_8002FB58:
-/* 8002FB58  7F A3 EB 78 */	mr r3, r29
-/* 8002FB5C  7F C4 F3 78 */	mr r4, r30
-/* 8002FB60  7F E5 FB 78 */	mr r5, r31
-/* 8002FB64  4B FF FF BD */	bl dComLbG_PhaseHandler__FP30request_of_phase_process_classPPFPv_iPv
-lbl_8002FB68:
-/* 8002FB68  39 61 00 20 */	addi r11, r1, 0x20
-/* 8002FB6C  48 33 26 BD */	bl _restgpr_29
-/* 8002FB70  80 01 00 24 */	lwz r0, 0x24(r1)
-/* 8002FB74  7C 08 03 A6 */	mtlr r0
-/* 8002FB78  38 21 00 20 */	addi r1, r1, 0x20
-/* 8002FB7C  4E 80 00 20 */	blr 
diff --git a/include/JSystem/JKernel/JKRDvdFile.h b/include/JSystem/JKernel/JKRDvdFile.h
index a777f83047..4a9daa94e7 100644
--- a/include/JSystem/JKernel/JKRDvdFile.h
+++ b/include/JSystem/JKernel/JKRDvdFile.h
@@ -20,7 +20,7 @@ public:
     s32 sync(void);
 
     u32 getFileID() const { return mFileInfo.start_address; }
-    const DVDFileInfo& getFileInfo() const { return mFileInfo; }
+    DVDFileInfo* getFileInfo() { return &mFileInfo; }
     int getStatus() { return DVDGetCommandBlockStatus(&mFileInfo.block); }
 
 public:
diff --git a/include/JSystem/JKernel/JKRDvdRipper.h b/include/JSystem/JKernel/JKRDvdRipper.h
index d0c9a7030a..0b6ec79330 100644
--- a/include/JSystem/JKernel/JKRDvdRipper.h
+++ b/include/JSystem/JKernel/JKRDvdRipper.h
@@ -10,6 +10,11 @@ enum JKRExpandSwitch {
     EXPAND_SWITCH_UNKNOWN2 = 2,
 };
 
+struct SYaz0Header {
+    u32 signature;
+    u32 length;
+};
+
 class JKRHeap;
 class JKRDvdFile;
 class JKRDvdRipper {
@@ -31,7 +36,7 @@ public:
     static void* loadToMainRAM(JKRDvdFile*, u8*, JKRExpandSwitch, u32, JKRHeap*, EAllocDirection,
                                u32, JKRCompression*, u32*);
 
-    u8 isErrorRetry(void);
+    static u8 isErrorRetry(void);
 };
 
 // void JKRDecompressFromDVD(JKRDvdFile*, void*, u32, u32, u32, u32, u32*);
diff --git a/include/dolphin/os/OSCache.h b/include/dolphin/os/OSCache.h
index fd26996f04..5d21ae7ecb 100644
--- a/include/dolphin/os/OSCache.h
+++ b/include/dolphin/os/OSCache.h
@@ -6,6 +6,7 @@
 extern "C" {
 void DCInvalidateRange(void*, u32);
 void DCStoreRange(void*, u32);
+void DCStoreRangeNoSync(void*, u32);
 }
 
 #endif /* OSCACHE_H */
diff --git a/libs/JSystem/J3DGraphAnimator/J3DModel.cpp b/libs/JSystem/J3DGraphAnimator/J3DModel.cpp
index 1b3a84df5d..25b90255e8 100644
--- a/libs/JSystem/J3DGraphAnimator/J3DModel.cpp
+++ b/libs/JSystem/J3DGraphAnimator/J3DModel.cpp
@@ -80,7 +80,6 @@ extern "C" void calc__15J3DVtxColorCalcFP8J3DModel();
 extern "C" void offAllFlag__13J3DDeformDataFUl();
 extern "C" void deform__13J3DDeformDataFP8J3DModel();
 extern "C" void entryIn__8J3DJointFv();
-extern "C" void DCStoreRangeNoSync();
 extern "C" void __construct_new_array();
 extern "C" void _savegpr_23();
 extern "C" void _savegpr_25();
diff --git a/libs/JSystem/JKernel/JKRAram.cpp b/libs/JSystem/JKernel/JKRAram.cpp
index 2e62f309a0..73e6a7dbad 100644
--- a/libs/JSystem/JKernel/JKRAram.cpp
+++ b/libs/JSystem/JKernel/JKRAram.cpp
@@ -252,13 +252,13 @@ static u8* szpBuf;
 static u8* szpEnd;
 
 /* 804513D4-804513D8 0008D4 0004+00 2/2 0/0 0/0 .sbss            refBuf */
-static u8 refBuf[4];
+static u8* refBuf;
 
 /* 804513D8-804513DC 0008D8 0004+00 2/2 0/0 0/0 .sbss            refEnd */
-static u8 refEnd[4];
+static u8* refEnd;
 
 /* 804513DC-804513E0 0008DC 0004+00 2/2 0/0 0/0 .sbss            refCurrent */
-static u8 refCurrent[4];
+static u8* refCurrent;
 
 /* 804513E0-804513E4 0008E0 0004+00 3/3 0/0 0/0 .sbss            srcOffset */
 static u32 srcOffset;
@@ -267,28 +267,28 @@ static u32 srcOffset;
 static u32 transLeft;
 
 /* 804513E8-804513EC 0008E8 0004+00 3/3 0/0 0/0 .sbss            srcLimit */
-static u32 srcLimit;
+static u8* srcLimit;
 
 /* 804513EC-804513F0 0008EC 0004+00 3/3 0/0 0/0 .sbss            srcAddress */
 static u32 srcAddress;
 
 /* 804513F0-804513F4 0008F0 0004+00 2/2 0/0 0/0 .sbss            fileOffset */
-static u8 fileOffset[4];
+static u32 fileOffset;
 
 /* 804513F4-804513F8 0008F4 0004+00 2/2 0/0 0/0 .sbss            readCount */
-static u8 readCount[4];
+static u32 readCount;
 
 /* 804513F8-804513FC 0008F8 0004+00 2/2 0/0 0/0 .sbss            maxDest */
-static u8 maxDest[4];
+static u32 maxDest;
 
 /* 804513FC-80451400 0008FC 0004+00 1/1 0/0 0/0 .sbss            None */
 static u8 data_804513FC[4];
 
 /* 80451400-80451404 000900 0004+00 2/2 0/0 0/0 .sbss            tsPtr */
-static u8 tsPtr[4];
+static u32* tsPtr;
 
 /* 80451404-80451408 000904 0004+00 1/1 0/0 0/0 .sbss            tsArea */
-static u8 tsArea[4];
+static u32 tsArea;
 
 /* 802D2830-802D29A0 2CD170 0170+00 1/1 0/0 0/0 .text
  * JKRDecompressFromAramToMainRam__FUlPvUlUlUlPUl               */
@@ -371,7 +371,7 @@ static asm void JKRDecompressFromAramToMainRam(u32 param_0, void* param_1, u32 p
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-static asm void decompSZS_subroutine(u8* param_0, u8* param_1) {
+static asm int decompSZS_subroutine(u8* param_0, u8* param_1) {
     nofralloc
 #include "asm/JSystem/JKernel/JKRAram/decompSZS_subroutine__FPUcPUc.s"
 }
@@ -379,7 +379,7 @@ static asm void decompSZS_subroutine(u8* param_0, u8* param_1) {
 
 /* 802D2C40-802D2CE4 2CD580 00A4+00 1/1 0/0 0/0 .text            firstSrcData__Fv */
 static u8* firstSrcData(void) {
-    srcLimit = (u32)(szpEnd - 0x19);
+    srcLimit = szpEnd - 0x19;
     u8* buffer = szpBuf;
 
     u32 length;
@@ -398,7 +398,7 @@ static u8* firstSrcData(void) {
     srcOffset += length;
     transLeft -= length;
     if (!transLeft) {
-        srcLimit = (u32)(buffer + length);
+        srcLimit = buffer + length;
     }
 
     return buffer;
@@ -441,7 +441,7 @@ static u8* nextSrcData(u8* current) {
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-static asm void nextSrcData(u8* param_0) {
+static asm u8* nextSrcData(u8* param_0) {
     nofralloc
 #include "asm/JSystem/JKernel/JKRAram/nextSrcData__FPUc.s"
 }
diff --git a/libs/JSystem/JKernel/JKRDvdRipper.cpp b/libs/JSystem/JKernel/JKRDvdRipper.cpp
index 4edf25e4fe..ac61b87dec 100644
--- a/libs/JSystem/JKernel/JKRDvdRipper.cpp
+++ b/libs/JSystem/JKernel/JKRDvdRipper.cpp
@@ -4,23 +4,33 @@
 //
 
 #include "JSystem/JKernel/JKRDvdRipper.h"
+#include "JSystem/JKernel/JKRDvdFile.h"
+#include "JSystem/JUtility/JUTException.h"
+#include "MSL_C/MSL_Common/Src/string.h"
 #include "dol2asm.h"
+#include "dolphin/os/OSCache.h"
 #include "dolphin/types.h"
+#include "global.h"
 
 //
 // Forward References:
 //
 
+static int JKRDecompressFromDVD(JKRDvdFile*, void*, u32, u32, u32, u32, u32*);
+static int decompSZS_subroutine(u8*, u8*);
+static u8* firstSrcData();
+static u8* nextSrcData(u8*);
+
 extern "C" void
 loadToMainRAM__12JKRDvdRipperFPCcPUc15JKRExpandSwitchUlP7JKRHeapQ212JKRDvdRipper15EAllocDirectionUlPiPUl();
 extern "C" void
 loadToMainRAM__12JKRDvdRipperFlPUc15JKRExpandSwitchUlP7JKRHeapQ212JKRDvdRipper15EAllocDirectionUlPiPUl();
 extern "C" void
 loadToMainRAM__12JKRDvdRipperFP10JKRDvdFilePUc15JKRExpandSwitchUlP7JKRHeapQ212JKRDvdRipper15EAllocDirectionUlPiPUl();
-extern "C" static void JKRDecompressFromDVD__FP10JKRDvdFilePvUlUlUlUlPUl();
-extern "C" static void decompSZS_subroutine__FPUcPUc();
-extern "C" static void firstSrcData__Fv();
-extern "C" static void nextSrcData__FPUc();
+extern "C" static int JKRDecompressFromDVD__FP10JKRDvdFilePvUlUlUlUlPUl();
+extern "C" static int decompSZS_subroutine__FPUcPUc();
+extern "C" static u8* firstSrcData__Fv();
+extern "C" static u8* nextSrcData__FPUc();
 extern "C" u8 isErrorRetry__12JKRDvdRipperFv();
 extern "C" void __sinit_JKRDvdRipper_cpp();
 extern "C" void func_802DA820(void* _this);
@@ -32,7 +42,6 @@ extern "C" u32 sSZSBufferSize__12JKRDvdRipper;
 // External References:
 //
 
-SECTION_INIT void memcpy();
 extern "C" void alloc__7JKRHeapFUliP7JKRHeap();
 extern "C" void alloc__7JKRHeapFUli();
 extern "C" void free__7JKRHeapFPvP7JKRHeap();
@@ -46,8 +55,6 @@ extern "C" void checkCompressed__9JKRDecompFPUc();
 extern "C" void __dt__10JSUPtrListFv();
 extern "C" void initiate__10JSUPtrListFv();
 extern "C" void panic_f__12JUTExceptionFPCciPCce();
-extern "C" void DCInvalidateRange();
-extern "C" void DCStoreRangeNoSync();
 extern "C" void VIWaitForRetrace();
 extern "C" void __register_global_object();
 extern "C" void _savegpr_18();
@@ -69,32 +76,32 @@ extern "C" u8 sSystemHeap__7JKRHeap[4];
 /* 802D9B98-802D9C54 2D44D8 00BC+00 0/0 1/1 0/0 .text
  * loadToMainRAM__12JKRDvdRipperFPCcPUc15JKRExpandSwitchUlP7JKRHeapQ212JKRDvdRipper15EAllocDirectionUlPiPUl
  */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void* JKRDvdRipper::loadToMainRAM(char const* param_0, u8* param_1, JKRExpandSwitch param_2,
-                                      u32 param_3, JKRHeap* param_4,
-                                      JKRDvdRipper::EAllocDirection param_5, u32 param_6,
-                                      int* param_7, u32* param_8) {
-    nofralloc
-#include "asm/JSystem/JKernel/JKRDvdRipper/func_802D9B98.s"
+void* JKRDvdRipper::loadToMainRAM(char const* name, u8* dst, JKRExpandSwitch expandSwitch,
+                                  u32 dstLength, JKRHeap* heap,
+                                  JKRDvdRipper::EAllocDirection allocDirection, u32 offset,
+                                  int* pCompression, u32* param_8) {
+    JKRDvdFile file;
+    if (!file.open(name)) {
+        return NULL;
+    }
+    return loadToMainRAM(&file, dst, expandSwitch, dstLength, heap, allocDirection, offset,
+                         pCompression, param_8);
 }
-#pragma pop
 
 /* 802D9C54-802D9D10 2D4594 00BC+00 0/0 9/9 0/0 .text
  * loadToMainRAM__12JKRDvdRipperFlPUc15JKRExpandSwitchUlP7JKRHeapQ212JKRDvdRipper15EAllocDirectionUlPiPUl
  */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void* JKRDvdRipper::loadToMainRAM(s32 param_0, u8* param_1, JKRExpandSwitch param_2,
-                                      u32 param_3, JKRHeap* param_4,
-                                      JKRDvdRipper::EAllocDirection param_5, u32 param_6,
-                                      int* param_7, u32* param_8) {
-    nofralloc
-#include "asm/JSystem/JKernel/JKRDvdRipper/func_802D9C54.s"
+void* JKRDvdRipper::loadToMainRAM(s32 entryNumber, u8* dst, JKRExpandSwitch expandSwitch,
+                                  u32 dstLength, JKRHeap* heap,
+                                  JKRDvdRipper::EAllocDirection allocDirection, u32 offset,
+                                  int* pCompression, u32* param_8) {
+    JKRDvdFile file;
+    if (!file.open(entryNumber)) {
+        return NULL;
+    }
+    return loadToMainRAM(&file, dst, expandSwitch, dstLength, heap, allocDirection, offset,
+                         pCompression, param_8);
 }
-#pragma pop
 
 /* ############################################################################################## */
 /* 8039D290-8039D290 0298F0 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
@@ -109,11 +116,173 @@ SECTION_DEAD static char const* const pad_8039D2E9 = "\0\0\0\0\0\0";
 #pragma pop
 
 /* 804508C8-804508CC 000348 0004+00 3/2 0/0 0/0 .sdata           None */
-SECTION_SDATA static u32 data_804508C8 = 0x01000000;
+SECTION_SDATA static u8 data_804508C8 = 0x01;
 
 /* 802D9D10-802DA1E4 2D4650 04D4+00 2/2 0/0 0/0 .text
  * loadToMainRAM__12JKRDvdRipperFP10JKRDvdFilePUc15JKRExpandSwitchUlP7JKRHeapQ212JKRDvdRipper15EAllocDirectionUlPiPUl
  */
+#ifdef NONMATCHING
+void* JKRDvdRipper::loadToMainRAM(JKRDvdFile* dvdFile, u8* dst, JKRExpandSwitch expandSwitch,
+                                  u32 dstLength, JKRHeap* heap,
+                                  JKRDvdRipper::EAllocDirection allocDirection, u32 offset,
+                                  int* pCompression, u32* param_8) {
+    bool did_alloc = false;
+    int compression = 0;
+    u8* mem = NULL;
+    u32 fileSizeAligned = ALIGN_NEXT(dvdFile->getFileSize(), 0x20);
+    u32 r26;
+    if (expandSwitch == EXPAND_SWITCH_UNKNOWN1) {
+        u8 buffer[0x40];
+        u8* bufPtr = (u8*)ALIGN_NEXT((u32)buffer, 0x20);
+        while (true) {
+            s32 count = DVDReadPrio(dvdFile->getFileInfo(), bufPtr, 0x20, 0, 2);
+            if (count >= 0) {
+                break;
+            }
+            if (count == -3 || !data_804508C8) {
+                return NULL;
+            }
+            VIWaitForRetrace();
+        }
+        DCInvalidateRange(bufPtr, 0x20);
+        compression = JKRDecomp::checkCompressed(bufPtr);
+        if (compression == 3) {
+            compression = 0;
+        }
+        r26 = (bufPtr[4] << 0x18) | (bufPtr[5] << 0x10) | (bufPtr[6] << 0x08) | (bufPtr[7]);
+    }
+    if (pCompression) {
+        *pCompression = compression;
+    }
+    if (expandSwitch == EXPAND_SWITCH_UNKNOWN1 && compression) {
+        if (dstLength != 0 && r26 > dstLength) {
+            r26 = dstLength;
+        }
+        if (!dst) {
+            dst = (u8*)JKRHeap::alloc(r26, allocDirection == ALLOC_DIRECTION_FORWARD ? 0x20 : -0x20,
+                                      heap);
+            did_alloc = true;
+        }
+        if (!dst) {
+            return NULL;
+        }
+        if (compression == 1) {
+            mem = (u8*)JKRHeap::alloc(fileSizeAligned, 0x20, heap);
+            if (mem == NULL && did_alloc == true) {
+                JKRHeap::free(dst, NULL);
+                return NULL;
+            }
+        }
+    } else {
+        if (!dst) {
+            u32 var2 = fileSizeAligned - offset;
+            if (dstLength != 0 && var2 > dstLength) {
+                var2 = dstLength;
+            }
+            dst = (u8*)JKRHeap::alloc(
+                var2, allocDirection == ALLOC_DIRECTION_FORWARD ? 0x20 : -0x20, heap);
+            did_alloc = true;
+        }
+        if (!dst) {
+            return NULL;
+        }
+    }
+    if (compression == 0) {
+        int count = 0;
+        if (offset != 0) {
+            u8 buffer[0x40];
+            u8* bufPtr = (u8*)ALIGN_NEXT((u32)buffer, 0x20);
+            while (true) {
+                count = DVDReadPrio(dvdFile->getFileInfo(), bufPtr, 0x20, offset, 2);
+                if (count >= 0) {
+                    break;
+                }
+                if (count == -3 || !data_804508C8) {
+                    if (did_alloc == true) {
+                        JKRHeap::free(dst, NULL);
+                    }
+                    return NULL;
+                }
+                VIWaitForRetrace();
+            }
+            DCInvalidateRange(bufPtr, 0x20);
+            count = JKRDecomp::checkCompressed(bufPtr);
+            if (count == 3) {
+                count = 0;
+            }
+        }
+        if (count == 0 || expandSwitch == EXPAND_SWITCH_UNKNOWN2 ||
+            expandSwitch == EXPAND_SWITCH_UNKNOWN0) {
+            fileSizeAligned -= offset;
+            if (dstLength != 0 && dstLength < fileSizeAligned) {
+                fileSizeAligned = dstLength;
+            }
+            while (true) {
+                count = DVDReadPrio(dvdFile->getFileInfo(), dst, fileSizeAligned, offset, 2);
+                if (count >= 0) {
+                    break;
+                }
+                if (count == -3 || !data_804508C8) {
+                    if (did_alloc == true) {
+                        JKRHeap::free(dst, NULL);
+                    }
+                    return NULL;
+                }
+                VIWaitForRetrace();
+            }
+            if (param_8) {
+                *param_8 = fileSizeAligned;
+            }
+            return dst;
+        } else if (count == 2) {
+            JKRDecompressFromDVD(dvdFile, dst, fileSizeAligned, dstLength, 0, offset, param_8);
+        } else {
+            JUTException::panic_f("JKRDvdRipper.cpp", 0x143, "%s",
+                                  "Sorry, not applied for SZP archive.");
+        }
+        return dst;
+    } else if (compression == 1) {
+        if (offset) {
+            JUTException::panic_f("JKRDvdRipper.cpp", 0x14d, "%s",
+                                  "Not support SZP with offset read");
+        }
+        while (true) {
+            int count = DVDReadPrio(dvdFile->getFileInfo(), mem, fileSizeAligned, 0, 2);
+            if (count >= 0) {
+                break;
+            }
+            if (count == -3 || !data_804508C8) {
+                if (did_alloc == true) {
+                    JKRHeap::free(dst, NULL);
+                }
+                JKRHeap::free(mem, NULL);
+                return NULL;
+            }
+            VIWaitForRetrace();
+        }
+        DCInvalidateRange(mem, fileSizeAligned);
+        JKRDecomp::orderSync(mem, dst, r26, offset);
+        JKRHeap::free(mem, NULL);
+        if (param_8) {
+            *param_8 = r26;
+        }
+        return dst;
+    } else if (compression == 2) {
+        if (JKRDecompressFromDVD(dvdFile, dst, fileSizeAligned, r26, offset, 0, param_8)) {
+            if (did_alloc) {
+                JKRHeap::free(dst, NULL);
+            }
+            dst = NULL;
+        }
+        return dst;
+    } else {
+        if (did_alloc) {
+            JKRHeap::free(dst, NULL);
+        }
+        return NULL;
+    }
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
@@ -125,6 +294,7 @@ asm void* JKRDvdRipper::loadToMainRAM(JKRDvdFile* param_0, u8* param_1, JKRExpan
 #include "asm/JSystem/JKernel/JKRDvdRipper/func_802D9D10.s"
 }
 #pragma pop
+#endif
 
 /* ############################################################################################## */
 /* 80434378-80434384 061098 000C+00 1/1 0/0 0/0 .bss             @491 */
@@ -134,101 +304,304 @@ static u8 lit_491[12];
 u8 JKRDvdRipper::sDvdAsyncList[12];
 
 /* 80434390-804343A8 0610B0 0018+00 1/1 0/0 0/0 .bss             decompMutex */
-static u8 decompMutex[24];
+static OSMutex decompMutex;
 
 /* 804508CC-804508D0 00034C 0004+00 1/1 1/1 0/0 .sdata           sSZSBufferSize__12JKRDvdRipper */
 SECTION_SDATA u32 JKRDvdRipper::sSZSBufferSize = 0x00000400;
 
 /* 80451428-8045142C 000928 0004+00 3/3 0/0 0/0 .sbss            szpBuf */
-static u8 szpBuf[4];
+static u8* szpBuf;
 
 /* 8045142C-80451430 00092C 0004+00 3/3 0/0 0/0 .sbss            szpEnd */
-static u8 szpEnd[4];
+static u8* szpEnd;
 
 /* 80451430-80451434 000930 0004+00 2/2 0/0 0/0 .sbss            refBuf */
-static u8 refBuf[4];
+static u8* refBuf;
 
 /* 80451434-80451438 000934 0004+00 2/2 0/0 0/0 .sbss            refEnd */
-static u8 refEnd[4];
+static u8* refEnd;
 
 /* 80451438-8045143C 000938 0004+00 2/2 0/0 0/0 .sbss            refCurrent */
-static u8 refCurrent[4];
+static u8* refCurrent;
 
 /* 8045143C-80451440 00093C 0004+00 3/3 0/0 0/0 .sbss            srcOffset */
-static u8 srcOffset[4];
+static u32 srcOffset;
 
 /* 80451440-80451444 000940 0004+00 4/4 0/0 0/0 .sbss            transLeft */
-static u8 transLeft[4];
+static u32 transLeft;
 
 /* 80451444-80451448 000944 0004+00 3/3 0/0 0/0 .sbss            srcLimit */
-static u8 srcLimit[4];
+static u8* srcLimit;
 
 /* 80451448-8045144C 000948 0004+00 3/3 0/0 0/0 .sbss            srcFile */
-static u8 srcFile[4];
+static JKRDvdFile* srcFile;
 
 /* 8045144C-80451450 00094C 0004+00 2/2 0/0 0/0 .sbss            fileOffset */
-static u8 fileOffset[4];
+static u32 fileOffset;
 
 /* 80451450-80451454 000950 0004+00 2/2 0/0 0/0 .sbss            readCount */
-static u8 readCount[4];
+static u32 readCount;
 
 /* 80451454-80451458 000954 0004+00 2/2 0/0 0/0 .sbss            maxDest */
-static u8 maxDest[4];
+static u32 maxDest;
 
 /* 80451458-8045145C 000958 0004+00 1/1 0/0 0/0 .sbss            None */
-static u8 data_80451458[4];
+static bool data_80451458;
 
 /* 8045145C-80451460 00095C 0004+00 2/2 0/0 0/0 .sbss            tsPtr */
-static u8 tsPtr[4];
+static u32* tsPtr;
 
 /* 80451460-80451468 000960 0004+04 1/1 0/0 0/0 .sbss            tsArea */
-static u8 tsArea[4 + 4 /* padding */];
+static u32 tsArea;
 
 /* 802DA1E4-802DA35C 2D4B24 0178+00 1/1 0/0 0/0 .text
  * JKRDecompressFromDVD__FP10JKRDvdFilePvUlUlUlUlPUl            */
+#ifdef NONMATCHING
+static int JKRDecompressFromDVD(JKRDvdFile* dvdFile, void* dst, u32 fileSize, u32 param_3,
+                                u32 param_4, u32 param_5, u32* param_6) {
+    BOOL level = OSDisableInterrupts();
+    if (!data_80451458) {
+        OSInitMutex(&decompMutex);
+        data_80451458 = true;
+    }
+    OSRestoreInterrupts(level);
+    OSLockMutex(&decompMutex);
+    u32 bufferSize = JKRDvdRipper::sSZSBufferSize;
+    szpBuf = (u8*)JKRHeap::sSystemHeap->alloc(bufferSize, -0x20);
+    szpEnd = szpBuf + bufferSize;
+    if (param_4) {
+        refBuf = (u8*)JKRHeap::sSystemHeap->alloc(0x1120, -4);
+        refEnd = refBuf + 0x1120;
+        refCurrent = refBuf;
+    } else {
+        refBuf = NULL;
+    }
+    srcFile = dvdFile;
+    srcOffset = param_5;
+    transLeft = fileSize - param_5;
+    fileOffset = param_4;
+    readCount = 0;
+    maxDest = param_3;
+    if (!param_6) {
+        tsPtr = &tsArea;
+    } else {
+        tsPtr = param_6;
+    }
+    *tsPtr = 0;
+    u8* first = firstSrcData();
+    int result = first ? decompSZS_subroutine(first, (u8*)dst) : -1;
+    JKRHeap::free(szpBuf, 0);
+    if (refBuf) {
+        JKRHeap::free(refBuf, 0);
+    }
+    DCStoreRangeNoSync(dst, *tsPtr);
+    OSUnlockMutex(&decompMutex);
+    return result;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-static asm void JKRDecompressFromDVD(JKRDvdFile* param_0, void* param_1, u32 param_2, u32 param_3,
-                                     u32 param_4, u32 param_5, u32* param_6) {
+static asm int JKRDecompressFromDVD(JKRDvdFile* param_0, void* param_1, u32 param_2, u32 param_3,
+                                    u32 param_4, u32 param_5, u32* param_6) {
     nofralloc
 #include "asm/JSystem/JKernel/JKRDvdRipper/JKRDecompressFromDVD__FP10JKRDvdFilePvUlUlUlUlPUl.s"
 }
 #pragma pop
+#endif
 
 /* 802DA35C-802DA60C 2D4C9C 02B0+00 1/1 0/0 0/0 .text            decompSZS_subroutine__FPUcPUc */
+#ifdef NONMATCHING
+int decompSZS_subroutine(u8* src, u8* dest) {
+    int validBitCount = 0;
+    u32 currCodeByte = 0;
+    u32 ts = 0;
+
+    if (src[0] != 'Y' || src[1] != 'a' || src[2] != 'z' || src[3] != '0') {
+        return -1;
+    }
+
+    SYaz0Header* header = (SYaz0Header*)src;
+    u8* endPtr = dest + (header->length - fileOffset);
+    if (endPtr > dest + maxDest) {
+        endPtr = dest + maxDest;
+    }
+
+    src += 0x10;
+    do {
+        if (validBitCount == 0) {
+            if ((src > srcLimit) && transLeft) {
+                src = nextSrcData(src);
+                if (!src) {
+                    return -1;
+                }
+            }
+            currCodeByte = *src;
+            validBitCount = 8;
+            src++;
+        }
+        if (currCodeByte & 0x80) {
+            if (fileOffset != 0) {
+                if (readCount >= fileOffset) {
+                    *dest = *src;
+                    dest++;
+                    ts++;
+                    if (dest == endPtr) {
+                        break;
+                    }
+                }
+                *(refCurrent++) = *src;
+                if (refCurrent == refEnd) {
+                    refCurrent = refBuf;
+                }
+                src++;
+            } else {
+                *dest = *src;
+                dest++;
+                src++;
+                ts++;
+                if (dest == endPtr) {
+                    break;
+                }
+            }
+            readCount++;
+        } else {
+            u32 dist = ((src[0] & 0x0f) << 8) | src[1];
+            s32 numBytes = src[0] >> 4;
+            src += 2;
+            u8* copySource;
+            if (fileOffset != 0) {
+                copySource = refCurrent - dist - 1;
+                if (copySource < refBuf) {
+                    copySource += refEnd - refBuf;
+                }
+            } else {
+                copySource = dest - dist - 1;
+            }
+            if (numBytes == 0) {
+                numBytes = *src + 0x12;
+                src += 1;
+            } else {
+                numBytes += 2;
+            }
+            if (fileOffset != 0) {
+                do {
+                    if (readCount >= fileOffset) {
+                        *dest = *copySource;
+                        dest++;
+                        ts++;
+                        if (dest == endPtr) {
+                            break;
+                        }
+                    }
+                    *(refCurrent++) = *copySource;
+                    if (refCurrent == refEnd) {
+                        refCurrent = refBuf;
+                    }
+                    copySource++;
+                    if (copySource == refEnd) {
+                        copySource = refBuf;
+                    }
+                    readCount++;
+                    numBytes--;
+                } while (numBytes != 0);
+            } else {
+                do {
+                    *dest = *copySource;
+                    dest++;
+                    ts++;
+                    if (dest == endPtr) {
+                        break;
+                    }
+                    readCount++;
+                    numBytes--;
+                    copySource++;
+                } while (numBytes != 0);
+            }
+        }
+        currCodeByte <<= 1;
+        validBitCount--;
+    } while (dest < endPtr);
+    *tsPtr = ts;
+    return 0;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-static asm void decompSZS_subroutine(u8* param_0, u8* param_1) {
+static asm int decompSZS_subroutine(u8* param_0, u8* param_1) {
     nofralloc
 #include "asm/JSystem/JKernel/JKRDvdRipper/decompSZS_subroutine__FPUcPUc.s"
 }
 #pragma pop
+#endif
 
 /* 802DA60C-802DA6D8 2D4F4C 00CC+00 1/1 0/0 0/0 .text            firstSrcData__Fv */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-static asm u8* firstSrcData() {
-    nofralloc
-#include "asm/JSystem/JKernel/JKRDvdRipper/firstSrcData__Fv.s"
+static u8* firstSrcData() {
+    srcLimit = szpEnd - 0x19;
+    u8* buffer = szpBuf;
+    u32 bufSize = szpEnd - buffer;
+    u32 length = transLeft < bufSize ? transLeft : bufSize;
+    while (true) {
+        int result = DVDReadPrio(srcFile->getFileInfo(), buffer, length, srcOffset, 2);
+        if (result >= 0) {
+            break;
+        }
+        if (result == -3 || !data_804508C8) {
+            return NULL;
+        }
+        VIWaitForRetrace();
+    }
+    DCInvalidateRange(buffer, length);
+    srcOffset += length;
+    transLeft -= length;
+    return buffer;
 }
-#pragma pop
 
 /* 802DA6D8-802DA7D4 2D5018 00FC+00 1/1 0/0 0/0 .text            nextSrcData__FPUc */
+#ifdef NONMATCHING
+static u8* nextSrcData(u8* param_0) {
+    u32 size = szpEnd - param_0;
+    u8* dest = IS_NOT_ALIGNED(size, 0x20) ? szpBuf + 0x20 - (size & (0x20 - 1)) : szpBuf;
+    memcpy(dest, param_0, size);
+    u8* end = dest + size;
+    u32 transSize = szpEnd - end;
+    if (transSize > transLeft) {
+        transSize = transLeft;
+    }
+    while (true) {
+        s32 result = DVDReadPrio(srcFile->getFileInfo(), end, transSize, srcOffset, 2);
+        if (result >= 0) {
+            break;
+        }
+        // bug: supposed to call isErrorRetry, but didn't
+        if (result == -3 || !JKRDvdRipper::isErrorRetry) {
+            return NULL;
+        }
+        VIWaitForRetrace();
+    }
+    DCInvalidateRange(end, transSize);
+    srcOffset += transSize;
+    transLeft -= transSize;
+    if (transLeft == 0) {
+        srcLimit = end + transSize;
+    }
+    return dest;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-static asm void nextSrcData(u8* param_0) {
+static asm u8* nextSrcData(u8* param_0) {
     nofralloc
 #include "asm/JSystem/JKernel/JKRDvdRipper/nextSrcData__FPUc.s"
 }
 #pragma pop
+#endif
 
 /* 802DA7D4-802DA7DC -00001 0008+00 0/0 0/0 0/0 .text            isErrorRetry__12JKRDvdRipperFv */
 u8 JKRDvdRipper::isErrorRetry() {
-    return *(u8*)(&data_804508C8);
+    return data_804508C8;
 }
 
 /* 802DA7DC-802DA820 2D511C 0044+00 0/0 1/0 0/0 .text            __sinit_JKRDvdRipper_cpp */
diff --git a/libs/JSystem/JKernel/JKRFileCache.cpp b/libs/JSystem/JKernel/JKRFileCache.cpp
index 5a0884456c..33f231947c 100644
--- a/libs/JSystem/JKernel/JKRFileCache.cpp
+++ b/libs/JSystem/JKernel/JKRFileCache.cpp
@@ -222,14 +222,14 @@ void* JKRFileCache::getResource(const char* path) {
         CCacheBlock* cacheBlock = findCacheBlock(dvdFile.getFileID());
         if (!cacheBlock) {
             // dvdFile.getFileSize() not inlined
-            u32 fileSize = dvdFile.getFileInfo().length;
+            u32 fileSize = dvdFile.getFileInfo()->length;
             u32 alignedSize = ALIGN_NEXT(fileSize, 0x20);
             buffer = JKRAllocFromHeap(mParentHeap, alignedSize, 0x20);
             if (buffer) {
                 dvdFile.read(buffer, alignedSize, 0);
 
                 cacheBlock = new (JKRHeap::getSystemHeap(), 0)
-                    CCacheBlock(dvdFile.getFileID(), dvdFile.getFileInfo().length, buffer);
+                    CCacheBlock(dvdFile.getFileID(), dvdFile.getFileInfo()->length, buffer);
                 mCacheBlockList.append(&cacheBlock->mCacheBlockLink);
             }
         } else {
@@ -273,7 +273,7 @@ u32 JKRFileCache::readResource(void* dst, u32 dstLength, const char* path) {
 loop:
     if (dvdFile.isAvailable()) {
         // dvdFile.getFileSize() not inlined
-        u32 fileSize = dvdFile.getFileInfo().length;
+        u32 fileSize = dvdFile.getFileInfo()->length;
         resourceSize = ALIGN_NEXT(fileSize, 0x20);
         dstLength = ALIGN_PREV(dstLength, 0x20);
         if (resourceSize > dstLength) {
diff --git a/libs/JSystem/JKernel/JKRSolidHeap.cpp b/libs/JSystem/JKernel/JKRSolidHeap.cpp
index 9c5d33ca36..79d79d5f6b 100644
--- a/libs/JSystem/JKernel/JKRSolidHeap.cpp
+++ b/libs/JSystem/JKernel/JKRSolidHeap.cpp
@@ -121,40 +121,27 @@ JKRSolidHeap::~JKRSolidHeap(void) {
 }
 
 /* 802D0BF4-802D0CB0 2CB534 00BC+00 0/0 5/5 1/1 .text            adjustSize__12JKRSolidHeapFv */
-#ifdef NONMATCHING
 s32 JKRSolidHeap::adjustSize(void) {
     JKRHeap* parent = getParent();
     if (parent) {
         lock();
-        s32 start = mStart;
-        s32 newSize = (s32)this->mSolidHead - ALIGN_NEXT(start, 0x20);
-        s32 newSizeThis = newSize + (start - (s32)this);
-        s32 actualSize = parent->resize(this, newSizeThis);
-        if (actualSize != -1) {
+        u32 thisSize = (u32)mStart - (u32)this;
+        u32 newSize = ALIGN_NEXT(mSolidHead - mStart, 0x20);
+        if (parent->resize(this, thisSize + newSize) != -1) {
             mFreeSize = 0;
             mSize = newSize;
             mEnd = mStart + mSize;
-            mSolidHead = (void*)mEnd;
-            mSolidTail = (void*)mEnd;
+            mSolidHead = mEnd;
+            mSolidTail = mEnd;
         }
 
         unlock();
 
-        return newSizeThis;
+        return thisSize + newSize;
     }
 
     return -1;
 }
-#else
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm s32 JKRSolidHeap::adjustSize() {
-    nofralloc
-#include "asm/JSystem/JKernel/JKRSolidHeap/adjustSize__12JKRSolidHeapFv.s"
-}
-#pragma pop
-#endif
 
 /* 802D0CB0-802D0D58 2CB5F0 00A8+00 1/0 0/0 0/0 .text            do_alloc__12JKRSolidHeapFUli */
 void* JKRSolidHeap::do_alloc(u32 size, int alignment) {
@@ -190,28 +177,14 @@ void* JKRSolidHeap::do_alloc(u32 size, int alignment) {
     return ptr;
 }
 
-/* ############################################################################################## */
-/* 8039CE50-8039CE50 0294B0 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
-#pragma push
-#pragma force_active on
-SECTION_DEAD static char const* const stringBase_8039CE50 =
-    "allocFromHead: cannot alloc memory (0x%x byte).\n";
-#pragma pop
-
 /* 802D0D58-802D0E20 2CB698 00C8+00 1/1 0/0 0/0 .text            allocFromHead__12JKRSolidHeapFUli
  */
-#ifdef NONMATCHING
 void* JKRSolidHeap::allocFromHead(u32 size, int alignment) {
-    void* ptr;
-    u32 offset;
-    u32 alignedSize;
-    u32 alignedStart;
-    u32 totalSize;
-    alignedSize = ALIGN_NEXT(size, 0x4);
-    ptr = NULL;
-    alignedStart = (alignment - 1 + (u32)mSolidHead) & ~(alignment - 1);
-    offset = alignedStart - (u32)mSolidHead;
-    totalSize = alignedSize + offset;
+    size = ALIGN_NEXT(size, 0x4);
+    void* ptr = NULL;
+    u32 alignedStart = (alignment - 1 + (u32)mSolidHead) & ~(alignment - 1);
+    u32 offset = alignedStart - (u32)mSolidHead;
+    u32 totalSize = size + offset;
     if (totalSize <= mFreeSize) {
         ptr = (void*)alignedStart;
         mSolidHead += totalSize;
@@ -219,41 +192,32 @@ void* JKRSolidHeap::allocFromHead(u32 size, int alignment) {
     } else {
         JUTWarningConsole_f("allocFromHead: cannot alloc memory (0x%x byte).\n", totalSize);
         if (getErrorFlag() == true) {
-            callErrorHandler(this, alignedSize, alignment);
+            callErrorHandler(this, size, alignment);
         }
     }
 
     return ptr;
 }
-#else
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void* JKRSolidHeap::allocFromHead(u32 param_0, int param_1) {
-    nofralloc
-#include "asm/JSystem/JKernel/JKRSolidHeap/allocFromHead__12JKRSolidHeapFUli.s"
-}
-#pragma pop
-#endif
-
-/* ############################################################################################## */
-/* 8039CE50-8039CE50 0294B0 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
-#pragma push
-#pragma force_active on
-SECTION_DEAD static char const* const stringBase_8039CE81 =
-    "allocFromTail: cannot alloc memory (0x%x byte).\n";
-#pragma pop
 
 /* 802D0E20-802D0EE4 2CB760 00C4+00 1/1 0/0 0/0 .text            allocFromTail__12JKRSolidHeapFUli
  */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void* JKRSolidHeap::allocFromTail(u32 param_0, int param_1) {
-    nofralloc
-#include "asm/JSystem/JKernel/JKRSolidHeap/allocFromTail__12JKRSolidHeapFUli.s"
+void* JKRSolidHeap::allocFromTail(u32 size, int alignment) {
+    size = ALIGN_NEXT(size, 4);
+    void* ptr = NULL;
+    u32 alignedStart = ALIGN_PREV((u32)mSolidTail - size, alignment);
+    u32 totalSize = (u32)mSolidTail - (u32)alignedStart;
+    if (totalSize <= mFreeSize) {
+        ptr = (void*)alignedStart;
+        mSolidTail -= totalSize;
+        mFreeSize -= totalSize;
+    } else {
+        JUTWarningConsole_f("allocFromTail: cannot alloc memory (0x%x byte).\n", totalSize);
+        if (getErrorFlag() == true) {
+            callErrorHandler(this, size, alignment);
+        }
+    }
+    return ptr;
 }
-#pragma pop
 
 /* 802D0EE4-802D0F14 2CB824 0030+00 1/0 0/0 0/0 .text            do_free__12JKRSolidHeapFPv */
 void JKRSolidHeap::do_free(void* ptr) {
diff --git a/libs/dolphin/os/OSCache.cpp b/libs/dolphin/os/OSCache.cpp
index 16d1902d91..13fe954b3c 100644
--- a/libs/dolphin/os/OSCache.cpp
+++ b/libs/dolphin/os/OSCache.cpp
@@ -15,7 +15,6 @@
 extern "C" static void DCEnable();
 extern "C" void DCFlushRange();
 extern "C" void DCFlushRangeNoSync();
-extern "C" void DCStoreRangeNoSync();
 extern "C" void DCZeroRange();
 extern "C" void ICInvalidateRange();
 extern "C" void ICFlashInvalidate();
@@ -106,7 +105,7 @@ asm void DCFlushRangeNoSync() {
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void DCStoreRangeNoSync() {
+asm void DCStoreRangeNoSync(void*, u32) {
     nofralloc
 #include "asm/dolphin/os/OSCache/DCStoreRangeNoSync.s"
 }
diff --git a/src/d/com/d_com_inf_game.cpp b/src/d/com/d_com_inf_game.cpp
index bc98c495aa..b7d19f9572 100644
--- a/src/d/com/d_com_inf_game.cpp
+++ b/src/d/com/d_com_inf_game.cpp
@@ -2541,26 +2541,19 @@ BOOL dComIfGp_TransportWarp_check() {
 
 /* 8002FB20-8002FB80 02A460 0060+00 2/2 6/6 0/0 .text
  * dComLbG_PhaseHandler__FP30request_of_phase_process_classPPFPv_iPv */
-#ifdef NONMATCHING
-int dComLbG_PhaseHandler(request_of_phase_process_class* param_0, int (**param_1)(void*),
+int dComLbG_PhaseHandler(request_of_phase_process_class* param_0, cPhs__Handler* param_1,
                          void* param_2) {
     int ret = cPhs_Handler(param_0, param_1, param_2);
-    if (ret != 2 && ret < 2) {
-        return ret;
+    switch (ret) {
+    case 2:
+        ret = dComLbG_PhaseHandler(param_0, param_1, param_2);
+        break;
+    case 1:
+    case 3:
+        break;
     }
-    return dComLbG_PhaseHandler(param_0, param_1, param_2);
-}
-#else
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm int dComLbG_PhaseHandler(request_of_phase_process_class* param_0, int (**param_1)(void*),
-                             void* param_2) {
-    nofralloc
-#include "asm/d/com/d_com_inf_game/dComLbG_PhaseHandler__FP30request_of_phase_process_classPPFPv_iPv.s"
+    return ret;
 }
-#pragma pop
-#endif
 
 /* 8002FB80-8002FC3C 02A4C0 00BC+00 0/0 1/1 1/1 .text            dComIfGs_onVisitedRoom__Fi */
 #pragma push