├── README.md └── haruspex-output ├── FUN_000000a8@000000a8.c ├── FUN_0000011a@0000011a.c ├── FUN_00000224@00000224.c ├── FUN_00000304@00000304.c ├── FUN_0000036e@0000036e.c ├── FUN_00000390@00000390.c ├── FUN_0000039c@0000039c.c ├── FUN_000003bc@000003bc.c ├── FUN_000003c8@000003c8.c ├── FUN_000003ea@000003ea.c ├── FUN_000003ec@000003ec.c ├── FUN_000003ee@000003ee.c ├── FUN_000003f0@000003f0.c ├── FUN_000003f2@000003f2.c ├── FUN_000003f4@000003f4.c ├── FUN_000003f6@000003f6.c ├── FUN_000003f8@000003f8.c ├── FUN_000003fa@000003fa.c ├── FUN_000003fc@000003fc.c ├── FUN_00000482@00000482.c ├── FUN_0000048c@0000048c.c ├── FUN_00000532@00000532.c ├── FUN_0000053c@0000053c.c ├── FUN_00000608@00000608.c ├── FUN_00000666@00000666.c ├── FUN_00000680@00000680.c ├── FUN_00000686@00000686.c ├── FUN_000006a8@000006a8.c ├── FUN_000006d6@000006d6.c ├── FUN_0000070e@0000070e.c ├── FUN_0000071e@0000071e.c ├── FUN_000007c6@000007c6.c ├── FUN_0000086c@0000086c.c ├── FUN_00000896@00000896.c ├── FUN_0000094c@0000094c.c ├── FUN_00000966@00000966.c ├── FUN_00000968@00000968.c ├── FUN_0000096a@0000096a.c ├── FUN_000009ac@000009ac.c ├── FUN_000009b0@000009b0.c ├── FUN_000009b4@000009b4.c ├── FUN_000009b8@000009b8.c ├── FUN_00000a3a@00000a3a.c ├── FUN_00000a82@00000a82.c ├── FUN_00000a94@00000a94.c ├── FUN_00001078@00001078.c ├── FUN_000010a4@000010a4.c ├── FUN_000011c2@000011c2.c ├── FUN_00001224@00001224.c ├── FUN_000012a0@000012a0.c ├── FUN_00001372@00001372.c ├── FUN_000014fc@000014fc.c ├── FUN_00001552@00001552.c ├── FUN_00001706@00001706.c ├── FUN_00001740@00001740.c ├── FUN_00001866@00001866.c ├── FUN_00001872@00001872.c ├── FUN_0000189e@0000189e.c ├── FUN_000018c8@000018c8.c ├── FUN_000018fc@000018fc.c ├── FUN_00001910@00001910.c ├── FUN_0000198e@0000198e.c ├── FUN_000019c0@000019c0.c ├── FUN_000019d4@000019d4.c ├── FUN_00001bb8@00001bb8.c ├── FUN_00001c04@00001c04.c ├── FUN_00001c60@00001c60.c ├── FUN_00001cae@00001cae.c ├── FUN_00001d34@00001d34.c ├── FUN_00001d7e@00001d7e.c ├── FUN_00001db6@00001db6.c ├── FUN_00001df2@00001df2.c ├── FUN_00001e3a@00001e3a.c ├── FUN_00001e54@00001e54.c ├── FUN_00001ebe@00001ebe.c ├── FUN_00001ed0@00001ed0.c ├── FUN_00001f04@00001f04.c ├── FUN_00001fbe@00001fbe.c ├── FUN_000022ae@000022ae.c ├── FUN_00002378@00002378.c ├── FUN_000023ac@000023ac.c ├── FUN_00002676@00002676.c ├── FUN_000026a0@000026a0.c ├── FUN_000026b6@000026b6.c ├── FUN_000026c2@000026c2.c ├── FUN_00002756@00002756.c ├── FUN_0000276c@0000276c.c ├── FUN_00002a94@00002a94.c ├── FUN_00002ae0@00002ae0.c ├── FUN_00002b62@00002b62.c ├── FUN_00002c04@00002c04.c ├── FUN_00002c76@00002c76.c ├── FUN_00002cec@00002cec.c ├── FUN_0000308c@0000308c.c ├── FUN_00003636@00003636.c ├── FUN_00003656@00003656.c ├── FUN_0000367e@0000367e.c ├── FUN_00003680@00003680.c ├── FUN_000036e8@000036e8.c ├── FUN_000037b2@000037b2.c ├── FUN_000039a4@000039a4.c ├── FUN_000039f4@000039f4.c ├── FUN_00003a60@00003a60.c ├── FUN_00003aa2@00003aa2.c ├── FUN_00003b00@00003b00.c ├── FUN_00003b5e@00003b5e.c ├── FUN_00003c18@00003c18.c ├── FUN_00003d20@00003d20.c ├── FUN_00003d9c@00003d9c.c ├── FUN_00004052@00004052.c ├── FUN_00004060@00004060.c ├── FUN_00004088@00004088.c ├── FUN_000040b8@000040b8.c ├── FUN_000040f8@000040f8.c ├── FUN_0000411e@0000411e.c ├── FUN_00004148@00004148.c ├── FUN_00004176@00004176.c ├── FUN_000041b4@000041b4.c ├── FUN_000042bc@000042bc.c ├── FUN_0000433c@0000433c.c ├── FUN_000043a6@000043a6.c ├── FUN_0000440a@0000440a.c ├── FUN_0000444c@0000444c.c ├── FUN_0000452a@0000452a.c ├── FUN_00004554@00004554.c ├── FUN_00004590@00004590.c ├── FUN_00004614@00004614.c ├── FUN_00004778@00004778.c ├── FUN_000047a2@000047a2.c ├── FUN_000047d0@000047d0.c ├── FUN_000047fc@000047fc.c ├── FUN_0000498a@0000498a.c ├── FUN_00004a18@00004a18.c ├── FUN_00004ad4@00004ad4.c ├── FUN_00004b0e@00004b0e.c ├── FUN_00004cc6@00004cc6.c ├── FUN_00004cea@00004cea.c ├── FUN_00004d12@00004d12.c ├── FUN_00004d36@00004d36.c ├── FUN_00004d5e@00004d5e.c ├── FUN_00004d82@00004d82.c ├── FUN_00004dcc@00004dcc.c ├── FUN_00004e3e@00004e3e.c ├── FUN_00004ec4@00004ec4.c ├── FUN_00004f0e@00004f0e.c ├── FUN_00004fc6@00004fc6.c ├── FUN_00005014@00005014.c ├── FUN_0000505c@0000505c.c ├── FUN_000051ac@000051ac.c ├── FUN_000052a0@000052a0.c ├── FUN_0000533e@0000533e.c ├── FUN_000053f2@000053f2.c ├── FUN_00005754@00005754.c ├── FUN_000057a2@000057a2.c ├── FUN_000057ba@000057ba.c ├── FUN_000057d6@000057d6.c ├── FUN_00005872@00005872.c ├── FUN_00005930@00005930.c ├── FUN_00005972@00005972.c ├── FUN_000059bc@000059bc.c ├── FUN_000059de@000059de.c ├── FUN_00005c58@00005c58.c ├── FUN_0000692a@0000692a.c ├── FUN_00006a26@00006a26.c ├── FUN_00006a70@00006a70.c ├── FUN_00006aaa@00006aaa.c ├── FUN_00006b48@00006b48.c ├── FUN_00006b96@00006b96.c ├── FUN_00006c4e@00006c4e.c ├── FUN_00006cb2@00006cb2.c ├── FUN_0000704e@0000704e.c ├── FUN_00007450@00007450.c ├── FUN_00007476@00007476.c ├── FUN_000074be@000074be.c ├── FUN_000074ca@000074ca.c ├── FUN_00007520@00007520.c ├── FUN_0000757e@0000757e.c ├── FUN_0000759c@0000759c.c ├── FUN_00007672@00007672.c ├── FUN_000076d0@000076d0.c ├── FUN_00007796@00007796.c ├── FUN_00007842@00007842.c ├── FUN_000078ba@000078ba.c ├── FUN_00007904@00007904.c ├── FUN_0000798c@0000798c.c ├── FUN_00007994@00007994.c ├── FUN_000079a8@000079a8.c ├── FUN_00007a10@00007a10.c ├── FUN_00007ab0@00007ab0.c ├── FUN_00007c54@00007c54.c ├── FUN_00007c64@00007c64.c ├── FUN_00007c6e@00007c6e.c ├── FUN_00007d02@00007d02.c ├── FUN_00007d84@00007d84.c ├── FUN_00007d9e@00007d9e.c ├── FUN_00007dca@00007dca.c ├── FUN_00007e18@00007e18.c ├── FUN_00007e6a@00007e6a.c ├── FUN_00007e92@00007e92.c ├── FUN_00007eaa@00007eaa.c ├── FUN_00007eac@00007eac.c ├── FUN_00007eae@00007eae.c ├── FUN_00007f14@00007f14.c ├── FUN_00008010@00008010.c ├── FUN_0000803c@0000803c.c ├── FUN_0000806a@0000806a.c ├── FUN_00008076@00008076.c ├── FUN_00008112@00008112.c ├── FUN_00008120@00008120.c ├── FUN_0000815c@0000815c.c ├── FUN_00008174@00008174.c ├── FUN_000081e8@000081e8.c ├── FUN_00008212@00008212.c ├── FUN_00008262@00008262.c ├── FUN_00008296@00008296.c ├── FUN_000082a4@000082a4.c ├── FUN_00008426@00008426.c ├── FUN_0000846c@0000846c.c ├── FUN_000084ac@000084ac.c ├── FUN_0000858c@0000858c.c ├── FUN_000085b8@000085b8.c ├── FUN_000086e6@000086e6.c ├── FUN_00008774@00008774.c ├── FUN_00008d34@00008d34.c ├── FUN_00008fde@00008fde.c ├── FUN_00008fe4@00008fe4.c ├── FUN_0000906a@0000906a.c ├── FUN_00009084@00009084.c ├── FUN_000090a8@000090a8.c ├── FUN_000090ee@000090ee.c ├── FUN_00009128@00009128.c ├── FUN_00009142@00009142.c ├── FUN_00009170@00009170.c ├── FUN_00009188@00009188.c ├── FUN_000091bc@000091bc.c ├── FUN_00009222@00009222.c ├── FUN_00009336@00009336.c ├── FUN_00009366@00009366.c ├── FUN_0000971e@0000971e.c ├── FUN_000097bc@000097bc.c ├── FUN_000097fe@000097fe.c ├── FUN_0000982c@0000982c.c ├── FUN_000098ec@000098ec.c ├── FUN_000098fe@000098fe.c ├── FUN_00009954@00009954.c ├── FUN_000099d8@000099d8.c ├── FUN_000099ea@000099ea.c ├── FUN_00009a40@00009a40.c ├── FUN_00009ca4@00009ca4.c ├── FUN_00009cdc@00009cdc.c ├── FUN_00009d1e@00009d1e.c ├── FUN_00009d90@00009d90.c ├── FUN_00009e48@00009e48.c ├── FUN_00009e56@00009e56.c ├── FUN_00009e74@00009e74.c ├── FUN_00009fd2@00009fd2.c ├── FUN_0000a1a4@0000a1a4.c ├── FUN_0000a2a2@0000a2a2.c ├── FUN_0000a2ac@0000a2ac.c ├── FUN_0000a332@0000a332.c ├── FUN_0000a3e8@0000a3e8.c ├── FUN_0000a468@0000a468.c ├── FUN_0000a476@0000a476.c ├── FUN_0000a48c@0000a48c.c ├── FUN_0000a4d4@0000a4d4.c ├── FUN_0000a4d8@0000a4d8.c ├── FUN_0000a4dc@0000a4dc.c ├── FUN_0000a4e0@0000a4e0.c ├── FUN_0000a4e4@0000a4e4.c ├── FUN_0000a5f8@0000a5f8.c ├── FUN_0000a780@0000a780.c ├── FUN_0000a7bc@0000a7bc.c ├── FUN_0000a7ca@0000a7ca.c ├── FUN_0000a7d8@0000a7d8.c ├── FUN_0000a7ea@0000a7ea.c ├── FUN_0000a7f8@0000a7f8.c ├── FUN_0000a806@0000a806.c ├── FUN_0000a814@0000a814.c ├── FUN_0000a824@0000a824.c ├── FUN_0000a964@0000a964.c ├── FUN_0000a9fe@0000a9fe.c ├── FUN_0000aa0c@0000aa0c.c ├── FUN_0000aa84@0000aa84.c ├── FUN_0000aaa0@0000aaa0.c ├── FUN_0000aaa8@0000aaa8.c ├── FUN_0000aae4@0000aae4.c ├── FUN_0000ab4c@0000ab4c.c ├── FUN_0000abda@0000abda.c ├── FUN_0000ac2c@0000ac2c.c ├── FUN_0000adac@0000adac.c ├── FUN_0000ae2c@0000ae2c.c ├── FUN_0000af30@0000af30.c ├── FUN_0000af6a@0000af6a.c ├── FUN_0000af7a@0000af7a.c ├── FUN_0000af96@0000af96.c ├── FUN_0000afa0@0000afa0.c ├── FUN_0000b092@0000b092.c ├── FUN_0000b0b8@0000b0b8.c ├── FUN_0000b15c@0000b15c.c ├── FUN_0000b18c@0000b18c.c ├── FUN_0000b27e@0000b27e.c ├── FUN_0000b2a4@0000b2a4.c ├── FUN_0000b2be@0000b2be.c ├── FUN_0000b310@0000b310.c ├── FUN_0000b33e@0000b33e.c ├── FUN_0000b354@0000b354.c ├── FUN_0000b388@0000b388.c ├── FUN_0000b3a0@0000b3a0.c ├── FUN_0000b3cc@0000b3cc.c ├── FUN_0000b63a@0000b63a.c ├── FUN_0000b6be@0000b6be.c ├── FUN_0000b6ca@0000b6ca.c ├── FUN_0000b6f0@0000b6f0.c ├── FUN_0000b774@0000b774.c ├── FUN_0000b794@0000b794.c ├── FUN_0000b798@0000b798.c ├── FUN_0000b7b6@0000b7b6.c ├── FUN_0000b824@0000b824.c ├── FUN_0000b83c@0000b83c.c ├── FUN_0000b844@0000b844.c ├── FUN_0000b898@0000b898.c ├── FUN_0000b8a2@0000b8a2.c ├── FUN_0000b8a8@0000b8a8.c ├── FUN_0000b8b8@0000b8b8.c ├── FUN_0000ba74@0000ba74.c ├── FUN_0000ba8c@0000ba8c.c ├── FUN_0000baa0@0000baa0.c ├── FUN_0000babc@0000babc.c ├── FUN_0000bae2@0000bae2.c ├── FUN_0000bbee@0000bbee.c ├── FUN_0000beda@0000beda.c ├── FUN_0000bf1c@0000bf1c.c ├── FUN_0000bf38@0000bf38.c ├── FUN_0000bf98@0000bf98.c ├── FUN_0000c042@0000c042.c ├── FUN_0000c162@0000c162.c ├── FUN_0000c1b2@0000c1b2.c ├── FUN_0000c1f4@0000c1f4.c ├── FUN_0000c242@0000c242.c ├── FUN_0000c2ae@0000c2ae.c ├── FUN_0000c308@0000c308.c ├── FUN_0000c35e@0000c35e.c ├── FUN_0000c392@0000c392.c ├── FUN_0000c3e6@0000c3e6.c ├── FUN_0000c3f8@0000c3f8.c ├── FUN_0000c420@0000c420.c ├── FUN_0000c426@0000c426.c ├── FUN_0000c454@0000c454.c ├── FUN_0000c4b4@0000c4b4.c ├── FUN_0000c4fa@0000c4fa.c ├── FUN_0000c506@0000c506.c ├── FUN_0000c55c@0000c55c.c ├── FUN_0000c572@0000c572.c ├── FUN_0000c612@0000c612.c ├── FUN_0000c61a@0000c61a.c ├── FUN_0000c626@0000c626.c ├── FUN_0000c67c@0000c67c.c ├── FUN_0000c77a@0000c77a.c ├── FUN_0000c7a8@0000c7a8.c ├── FUN_0000c7f4@0000c7f4.c ├── FUN_0000c7f6@0000c7f6.c ├── FUN_0000c854@0000c854.c ├── FUN_0000c8fc@0000c8fc.c ├── FUN_0000c960@0000c960.c ├── FUN_0000ca68@0000ca68.c ├── FUN_0000ca88@0000ca88.c ├── FUN_0000cac2@0000cac2.c ├── FUN_0000cb22@0000cb22.c ├── FUN_0000cb46@0000cb46.c ├── FUN_0000cc1c@0000cc1c.c ├── FUN_0000cc62@0000cc62.c ├── FUN_0000cc94@0000cc94.c ├── FUN_0000ccee@0000ccee.c ├── FUN_0000ce46@0000ce46.c ├── FUN_0000ce80@0000ce80.c ├── FUN_0000ceac@0000ceac.c ├── FUN_0000ced8@0000ced8.c ├── FUN_0000d044@0000d044.c ├── FUN_0000d186@0000d186.c ├── FUN_0000d19c@0000d19c.c ├── FUN_0000d292@0000d292.c ├── FUN_0000d298@0000d298.c ├── FUN_0000d2ac@0000d2ac.c ├── FUN_0000d2f0@0000d2f0.c ├── FUN_0000d4ba@0000d4ba.c ├── FUN_0000d534@0000d534.c ├── FUN_0000d6ce@0000d6ce.c ├── FUN_0000d750@0000d750.c ├── FUN_0000d834@0000d834.c ├── FUN_0000d850@0000d850.c ├── FUN_0000d86c@0000d86c.c ├── FUN_0000d968@0000d968.c ├── FUN_0000d9c4@0000d9c4.c ├── FUN_0000da10@0000da10.c ├── FUN_0000daca@0000daca.c ├── FUN_0000daf0@0000daf0.c ├── FUN_0000dc48@0000dc48.c ├── FUN_0000dc80@0000dc80.c ├── FUN_0000dd06@0000dd06.c ├── FUN_0000dd52@0000dd52.c ├── FUN_0000dd70@0000dd70.c ├── FUN_0000ddfa@0000ddfa.c ├── FUN_0000de22@0000de22.c ├── FUN_0000df1c@0000df1c.c ├── FUN_0000df42@0000df42.c ├── FUN_0000df56@0000df56.c ├── FUN_0000df7a@0000df7a.c ├── FUN_0000dfbc@0000dfbc.c ├── FUN_0000dfdc@0000dfdc.c ├── FUN_0000e008@0000e008.c ├── FUN_0000e072@0000e072.c ├── FUN_0000e09e@0000e09e.c ├── FUN_0000e13e@0000e13e.c ├── FUN_0000e198@0000e198.c ├── FUN_0000e21a@0000e21a.c ├── FUN_0000e260@0000e260.c ├── FUN_0000e28a@0000e28a.c ├── FUN_0000e2c8@0000e2c8.c ├── FUN_0000e320@0000e320.c ├── FUN_0000e396@0000e396.c ├── FUN_0000e3f0@0000e3f0.c ├── FUN_0000e460@0000e460.c ├── FUN_0000e48c@0000e48c.c ├── FUN_0000e48e@0000e48e.c ├── FUN_0000e53e@0000e53e.c ├── FUN_0000e552@0000e552.c ├── FUN_0000e598@0000e598.c ├── FUN_0000e642@0000e642.c ├── FUN_0000e682@0000e682.c ├── FUN_0000e6ae@0000e6ae.c ├── FUN_0000e788@0000e788.c ├── FUN_0000f6fa@0000f6fa.c ├── FUN_0001e8f2@0001e8f2.c ├── FUN_00020aec@00020aec.c ├── FUN_000287f2@000287f2.c ├── FUN_0002e5b8@0002e5b8.c ├── FUN_0002f3fe@0002f3fe.c ├── FUN_0003a670@0003a670.c ├── FUN_0005ace2@0005ace2.c ├── FUN_0005b4f0@0005b4f0.c ├── FUN_0005e850@0005e850.c ├── FUN_00075514@00075514.c ├── FUN_0007ab0e@0007ab0e.c ├── FUN_0007bb42@0007bb42.c ├── FUN_0007ee62@0007ee62.c ├── FUN_00090aec@00090aec.c ├── RetrieveMemoryInfo@0000c960.c ├── _rsa_verify@0000b18c.c ├── _sdram_config@00008d34.c ├── _sprintf_to_stdout@0000a2ac.c ├── _write_to_stderr@0000a2ac.c ├── _write_to_stdout@0000e198.c └── caseD_48@0000bdfe.c /README.md: -------------------------------------------------------------------------------- 1 | # Raspberry Pi EEPROM Decompiler output 2 | 3 | This is the haruspex output of my Ghidra Project for reverse engineering the VideoCore IV bootrom for the Raspberry Pi. -------------------------------------------------------------------------------- /haruspex-output/FUN_000000a8@000000a8.c: -------------------------------------------------------------------------------- 1 | 2 | ulonglong FUN_000000a8(uint param_1) 3 | 4 | { 5 | undefined4 extraout_r0; 6 | uint uVar1; 7 | undefined4 extraout_r1; 8 | uint uVar2; 9 | int iVar3; 10 | 11 | uVar1 = param_1 * 2 >> 0x18; 12 | if (uVar1 != 0) { 13 | if ((int)param_1 < 0) { 14 | FUN_000003fc(param_1); 15 | return CONCAT44(extraout_r1,extraout_r0); 16 | } 17 | uVar2 = param_1 & 0x7fffff | 0x800000; 18 | iVar3 = 0x96 - uVar1; 19 | if (iVar3 < 0) { 20 | iVar3 = uVar1 - 0x96; 21 | if (0x28 < iVar3) { 22 | return 0xffffffffffffffff; 23 | } 24 | if (0x1f < iVar3) { 25 | return (ulonglong)(uVar2 << uVar1 - 0xb6) << 0x20; 26 | } 27 | return CONCAT44(uVar2 >> 0x20 - iVar3,uVar2 << iVar3); 28 | } 29 | if (iVar3 < 0x20) { 30 | return (ulonglong)(uVar2 >> iVar3); 31 | } 32 | } 33 | return 0; 34 | } 35 | 36 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00000304@00000304.c: -------------------------------------------------------------------------------- 1 | 2 | ulonglong FUN_00000304(uint param_1,uint param_2,uint param_3,uint param_4) 3 | 4 | { 5 | undefined4 extraout_r2; 6 | undefined4 extraout_r3; 7 | 8 | if (param_2 != 0) { 9 | FUN_00000224(param_1,param_2,param_3,param_4); 10 | return CONCAT44(extraout_r3,extraout_r2); 11 | } 12 | if (param_4 == 0) { 13 | return (ulonglong)(param_1 - (param_1 / param_3) * param_3); 14 | } 15 | return (ulonglong)param_1; 16 | } 17 | 18 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000036e@0000036e.c: -------------------------------------------------------------------------------- 1 | 2 | ulonglong FUN_0000036e(uint param_1,uint param_2,int param_3) 3 | 4 | { 5 | int iVar1; 6 | uint uVar2; 7 | 8 | iVar1 = param_3 + -0x20; 9 | if (-1 < iVar1) { 10 | return (ulonglong)(param_2 >> iVar1); 11 | } 12 | if (param_3 != 0) { 13 | uVar2 = param_2 << -iVar1; 14 | param_2 = param_2 >> param_3; 15 | param_1 = param_1 >> param_3 | uVar2; 16 | } 17 | return CONCAT44(param_2,param_1); 18 | } 19 | 20 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00000390@00000390.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_00000390(uint param_1,uint param_2) 3 | 4 | { 5 | return param_1 - (param_1 / param_2) * param_2; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000039c@0000039c.c: -------------------------------------------------------------------------------- 1 | 2 | undefined8 FUN_0000039c(uint param_1,int param_2,uint param_3,int param_4) 3 | 4 | { 5 | return CONCAT44((int)((ulonglong)param_1 * (ulonglong)param_3 >> 0x20) + param_2 * param_3 + 6 | param_1 * param_4,param_1 * param_3); 7 | } 8 | 9 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000003bc@000003bc.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_000003bc(int param_1,int param_2) 3 | 4 | { 5 | return param_1 - (param_1 / param_2) * param_2; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000003c8@000003c8.c: -------------------------------------------------------------------------------- 1 | 2 | longlong FUN_000003c8(uint param_1,uint param_2,int param_3) 3 | 4 | { 5 | int iVar1; 6 | uint uVar2; 7 | 8 | iVar1 = param_3 + -0x20; 9 | if (-1 < iVar1) { 10 | return (ulonglong)(param_1 << iVar1) << 0x20; 11 | } 12 | if (param_3 != 0) { 13 | uVar2 = param_1 >> -iVar1; 14 | param_1 = param_1 << param_3; 15 | param_2 = param_2 << param_3 | uVar2; 16 | } 17 | return CONCAT44(param_2,param_1); 18 | } 19 | 20 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000003ea@000003ea.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_000003ea(void) 3 | 4 | { 5 | return; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000003ec@000003ec.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_000003ec(void) 3 | 4 | { 5 | return; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000003ee@000003ee.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_000003ee(void) 3 | 4 | { 5 | return; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000003f0@000003f0.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_000003f0(void) 3 | 4 | { 5 | return; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000003f2@000003f2.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_000003f2(void) 3 | 4 | { 5 | return; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000003f4@000003f4.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_000003f4(void) 3 | 4 | { 5 | return; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000003f6@000003f6.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_000003f6(void) 3 | 4 | { 5 | return; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000003f8@000003f8.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_000003f8(void) 3 | 4 | { 5 | return; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000003fa@000003fa.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_000003fa(void) 3 | 4 | { 5 | return; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00000482@00000482.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00000482(undefined4 param_1,undefined4 param_2) 3 | 4 | { 5 | code *pcVar1; 6 | undefined8 uVar2; 7 | 8 | uVar2 = CONCAT44(param_2,param_1); 9 | do { 10 | pcVar1 = (code *)swi(0xe); 11 | uVar2 = (*pcVar1)((int)uVar2,(int)((ulonglong)uVar2 >> 0x20)); 12 | } while( true ); 13 | } 14 | 15 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000048c@0000048c.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000048c(undefined4 param_1,undefined *UNRECOVERED_JUMPTABLE) 3 | 4 | { 5 | /* WARNING: Could not recover jumptable at 0x0000048c. Too many branches */ 6 | /* WARNING: Treating indirect jump as call */ 7 | (*(code *)UNRECOVERED_JUMPTABLE)(); 8 | return; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00000532@00000532.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00000532(void) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | FUN_0000198e(*(uint *)(unaff_gp + 0x52c)); 8 | return; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00000608@00000608.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_00000608(uint param_1) 5 | 6 | { 7 | _DAT_7d200020 = 8 | (uint)((param_1 & 0x20) != 0) << 10 | 9 | (uint)((param_1 & 0x10) != 0) << 8 | 10 | (uint)((param_1 & 8) != 0) << 6 | 11 | (uint)((param_1 & 4) != 0) << 4 | 12 | (uint)((param_1 & 2) != 0) << 2 | 13 | _DAT_7d200020 & 0xfffffaaa | 0x5a000000 | (uint)((param_1 & 1) != 0); 14 | return; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00000666@00000666.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | bool FUN_00000666(void) 5 | 6 | { 7 | uint uVar1; 8 | 9 | uVar1 = FUN_0000198e(_DAT_7d200020); 10 | return uVar1 == 0x3f; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00000680@00000680.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_00000680(void) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | return unaff_gp + 0x80; 8 | } 9 | 10 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00000686@00000686.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00000686(void) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | if (*(code **)(unaff_gp + 0x20) != (code *)0x0) { 8 | (**(code **)(unaff_gp + 0x20))(); 9 | } 10 | *(undefined4 *)(unaff_gp + 0x20) = 0; 11 | if (*(code **)(unaff_gp + 0x24) != (code *)0x0) { 12 | (**(code **)(unaff_gp + 0x24))(); 13 | } 14 | return; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000006a8@000006a8.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_000006a8(void) 3 | 4 | { 5 | undefined4 uVar1; 6 | int iVar2; 7 | int unaff_gp; 8 | 9 | if (*(int *)(unaff_gp + 0x2c) == 0) { 10 | iVar2 = *(int *)(unaff_gp + 0x5fc); 11 | *(undefined4 *)(unaff_gp + 0x2c) = 1; 12 | uVar1 = 0; 13 | *(undefined4 *)(unaff_gp + 0x5fc) = 0; 14 | for (; iVar2 != 0; iVar2 = *(int *)(iVar2 + 8)) { 15 | uVar1 = (**(code **)(iVar2 + 4))(uVar1,*(code **)(iVar2 + 4)); 16 | } 17 | } 18 | return; 19 | } 20 | 21 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000006d6@000006d6.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_000006d6(void) 3 | 4 | { 5 | int iVar1; 6 | int unaff_gp; 7 | 8 | iVar1 = *(int *)(unaff_gp + 0x5f4); 9 | *(undefined4 *)(unaff_gp + 0x5f4) = 0; 10 | for (; iVar1 != 0; iVar1 = *(int *)(iVar1 + 8)) { 11 | (**(code **)(iVar1 + 4))(*(code **)(iVar1 + 4)); 12 | } 13 | if (*(int *)(unaff_gp + 0x34) != 0) { 14 | FUN_00000a3a(0x6a8); 15 | *(undefined4 *)(unaff_gp + 0x34) = 0; 16 | } 17 | return; 18 | } 19 | 20 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000070e@0000070e.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000070e(uint *param_1) 3 | 4 | { 5 | FUN_0000c162(param_1,param_1[2] & 0xff,0); 6 | return 0; 7 | } 8 | 9 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000086c@0000086c.c: -------------------------------------------------------------------------------- 1 | 2 | uint FUN_0000086c(uint param_1,undefined4 param_2,int param_3) 3 | 4 | { 5 | uint uVar1; 6 | int iVar2; 7 | 8 | uVar1 = param_1 >> 0x17 & 0xff; 9 | iVar2 = uVar1 - 0x7e; 10 | if (iVar2 < 1) { 11 | param_1 = 0; 12 | } 13 | else { 14 | if (iVar2 < 0x19) { 15 | param_3 = 1 << 0x18 - iVar2; 16 | } 17 | if ((int)(uVar1 - 0x96) < 0 != SBORROW4(iVar2,0x18) || iVar2 == 0x18) { 18 | param_1 = param_1 & ~(param_3 - 1U); 19 | } 20 | } 21 | return param_1; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000094c@0000094c.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000094c(void) 3 | 4 | { 5 | return; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00000966@00000966.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00000966(void) 3 | 4 | { 5 | return; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00000968@00000968.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00000968(void) 3 | 4 | { 5 | return; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000096a@0000096a.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_0000096a(byte *param_1,byte *param_2,uint param_3) 3 | 4 | { 5 | uint uVar1; 6 | uint uVar2; 7 | uint uVar3; 8 | 9 | uVar3 = 0; 10 | do { 11 | while( true ) { 12 | if (param_3 <= uVar3) { 13 | return 0; 14 | } 15 | uVar2 = (uint)*param_1; 16 | uVar1 = (uint)*param_2; 17 | if (uVar2 != uVar1) break; 18 | param_1 = param_1 + 1; 19 | param_2 = param_2 + 1; 20 | uVar3 = uVar3 + 1; 21 | if (uVar2 == 0) { 22 | return 0; 23 | } 24 | } 25 | if (((&DAT_0000eee1)[uVar2] & 2) != 0) { 26 | uVar2 = uVar2 - 0x20; 27 | } 28 | if (((&DAT_0000eee1)[uVar1] & 2) != 0) { 29 | uVar1 = uVar1 - 0x20; 30 | } 31 | param_1 = param_1 + 1; 32 | param_2 = param_2 + 1; 33 | uVar3 = uVar3 + 1; 34 | } while (uVar2 == uVar1); 35 | return uVar2 - uVar1; 36 | } 37 | 38 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000009ac@000009ac.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_000009ac(void) 3 | 4 | { 5 | return 0; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000009b0@000009b0.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_000009b0(void) 3 | 4 | { 5 | return 0; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000009b4@000009b4.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_000009b4(void) 3 | 4 | { 5 | return 0; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00000a3a@00000a3a.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00000a3a(undefined4 param_1) 3 | 4 | { 5 | int iVar1; 6 | undefined4 uVar2; 7 | int unaff_gp; 8 | 9 | FUN_00000966(); 10 | iVar1 = *(int *)(unaff_gp + 0x1c); 11 | if (iVar1 < 0x24) { 12 | if (iVar1 == 0) { 13 | *(undefined **)(unaff_gp + 0x20) = &LAB_0000377e; 14 | } 15 | *(undefined4 *)(&LAB_000031c0 + iVar1 * 4 + unaff_gp) = param_1; 16 | uVar2 = 0; 17 | *(int *)(unaff_gp + 0x1c) = iVar1 + 1; 18 | } 19 | else { 20 | uVar2 = 0xffffffff; 21 | } 22 | FUN_00000968(); 23 | return uVar2; 24 | } 25 | 26 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00000a82@00000a82.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00000a82(void) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | FUN_00007e18((undefined4 *)(unaff_gp + 0x2c00),0,0x40); 8 | return; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00001078@00001078.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00001078(int param_1) 3 | 4 | { 5 | bool bVar1; 6 | undefined3 extraout_var; 7 | undefined3 extraout_var_00; 8 | int unaff_gp; 9 | 10 | if (*(int *)(param_1 + 0x10) != 0) { 11 | bVar1 = FUN_0000a7d8(); 12 | if ((CONCAT31(extraout_var,bVar1) == 0) && 13 | (bVar1 = FUN_0000a814(), CONCAT31(extraout_var_00,bVar1) == 0)) { 14 | *(undefined4 *)(&DAT_00002d10 + unaff_gp) = 0; 15 | } 16 | else { 17 | *(undefined4 *)(&DAT_00002d10 + unaff_gp) = 1; 18 | } 19 | } 20 | return; 21 | } 22 | 23 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00001224@00001224.c: -------------------------------------------------------------------------------- 1 | 2 | uint FUN_00001224(undefined4 param_1) 3 | 4 | { 5 | int iVar1; 6 | uint uVar2; 7 | uint auStack_10 [2]; 8 | 9 | switch(param_1) { 10 | case 0x1f: 11 | iVar1 = FUN_0000b8a2(); 12 | uVar2 = (**(code **)(iVar1 + 0x84))(param_1); 13 | if (uVar2 == 0) { 14 | uVar2 = 0x27122712; 15 | } 16 | break; 17 | case 0x20: 18 | iVar1 = FUN_0000b8a2(); 19 | uVar2 = (**(code **)(iVar1 + 0x84))(param_1,*(code **)(iVar1 + 0x84)); 20 | break; 21 | default: 22 | iVar1 = FUN_0000b8a2(); 23 | uVar2 = (**(code **)(iVar1 + 0x84))(param_1); 24 | break; 25 | case 0x32: 26 | case 0x33: 27 | case 0x34: 28 | case 0x35: 29 | case 0x36: 30 | case 0x37: 31 | iVar1 = FUN_000057ba(param_1); 32 | FUN_000043a6(iVar1,auStack_10); 33 | iVar1 = FUN_000057a2(param_1); 34 | uVar2 = auStack_10[iVar1]; 35 | } 36 | return uVar2; 37 | } 38 | 39 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000014fc@000014fc.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_000014fc(int param_1) 3 | 4 | { 5 | undefined4 uVar1; 6 | int iVar2; 7 | 8 | iVar2 = *(int *)(param_1 + 4); 9 | if (iVar2 == 0) { 10 | if (*(uint *)(param_1 + 0x10) < 2) { 11 | uVar1 = 0x90; 12 | *(undefined4 *)(param_1 + 0x18) = 2; 13 | } 14 | else { 15 | if (*(uint *)(param_1 + 0x10) == 2) { 16 | uVar1 = 0x10; 17 | } 18 | else { 19 | uVar1 = 0x30; 20 | } 21 | *(undefined4 *)(param_1 + 0x18) = 0; 22 | } 23 | FUN_00001866(param_1,0x28,uVar1); 24 | FUN_00001866(param_1,0x50,0x40); 25 | iVar2 = *(int *)(param_1 + 4); 26 | } 27 | *(int *)(param_1 + 4) = iVar2 + 1; 28 | return 0; 29 | } 30 | 31 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00001552@00001552.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00001552(void) 3 | 4 | { 5 | return DAT_0000e7e8; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00001706@00001706.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00001706(int param_1,uint param_2) 3 | 4 | { 5 | return *(undefined4 *)(*(int *)(param_1 + 0xc) + (param_2 & 0xfffffffc)); 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00001740@00001740.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | undefined4 FUN_00001740(int param_1) 5 | 6 | { 7 | uint uVar1; 8 | undefined4 uVar2; 9 | undefined4 extraout_r2; 10 | int extraout_r3; 11 | int extraout_r4; 12 | int extraout_r5; 13 | 14 | do { 15 | uVar1 = FUN_00001706(param_1,0x2c); 16 | if ((uVar1 & 2) != 0) break; 17 | param_1 = extraout_r5; 18 | } while ((undefined *)(*(int *)(extraout_r3 + 4) - extraout_r4) < &DAT_000186a0); 19 | if ((uVar1 & 2) == 0) { 20 | _write_to_stdout((byte *)s__s_transfer_timed_out_0000179c,*(uint *)(extraout_r5 + 8),extraout_r2 21 | ,extraout_r3,extraout_r4,extraout_r5); 22 | uVar2 = 0xffffffff; 23 | } 24 | else if ((uVar1 & 4) == 0) { 25 | uVar2 = 0; 26 | } 27 | else { 28 | _write_to_stdout((byte *)s__s_no_ACK_00001790,*(uint *)(extraout_r5 + 8),extraout_r2,extraout_r3 29 | ,extraout_r4,extraout_r5); 30 | uVar2 = 0xfffffffe; 31 | } 32 | return uVar2; 33 | } 34 | 35 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00001866@00001866.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00001866(int param_1,uint param_2,undefined4 param_3) 3 | 4 | { 5 | *(undefined4 *)(*(int *)(param_1 + 0xc) + (param_2 & 0xfffffffc)) = param_3; 6 | return; 7 | } 8 | 9 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00001872@00001872.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00001872(int param_1,undefined param_2) 3 | 4 | { 5 | uint uVar1; 6 | 7 | uVar1 = *(uint *)(param_1 + 8); 8 | *(undefined *)(param_1 + (uVar1 & 3) + 0x10) = param_2; 9 | if ((uVar1 & 3) == 3) { 10 | *(undefined4 *)(*(int *)(param_1 + 4) + (uVar1 & 0xfffffffc)) = *(undefined4 *)(param_1 + 0x10); 11 | *(undefined4 *)(param_1 + 0x10) = 0; 12 | uVar1 = *(uint *)(param_1 + 8); 13 | } 14 | *(uint *)(param_1 + 8) = uVar1 + 1; 15 | return; 16 | } 17 | 18 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000189e@0000189e.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000189e(int *param_1,uint param_2,uint param_3,int param_4,int param_5,undefined4 param_6) 3 | 4 | { 5 | if ((((param_1 == (int *)0x0) || (param_5 = *param_1, param_5 != 0x42554646)) || 6 | (param_4 = param_1[1], param_4 == 0)) || 7 | ((param_2 = param_1[3], param_2 == 0 || (param_3 = param_1[2], param_2 < param_3)))) { 8 | FUN_00009cdc(param_1,param_2,param_3,param_4,param_5,param_6); 9 | } 10 | return; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000018c8@000018c8.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_000018c8(int param_1) 3 | 4 | { 5 | uint uVar1; 6 | uint uVar2; 7 | undefined4 uVar3; 8 | 9 | if ((*(uint *)(param_1 + 8) & 3) != 0) { 10 | uVar2 = *(uint *)(param_1 + 8) & 0xfffffffc; 11 | uVar3 = *(undefined4 *)(param_1 + 0x10); 12 | *(undefined4 *)(*(int *)(param_1 + 4) + uVar2) = uVar3; 13 | *(undefined4 *)(param_1 + 0x10) = 0; 14 | uVar1 = *(int *)(param_1 + 8) + 3U & 0xfffffffc; 15 | *(uint *)(param_1 + 8) = uVar1; 16 | if (*(uint *)(param_1 + 0xc) < uVar1) { 17 | FUN_00009cdc(param_1,uVar1,uVar2,0,*(uint *)(param_1 + 0xc),uVar3); 18 | } 19 | } 20 | return; 21 | } 22 | 23 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000018fc@000018fc.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_000018fc(undefined4 *param_1,undefined4 param_2,undefined4 param_3) 3 | 4 | { 5 | *param_1 = 0x42554646; 6 | param_1[1] = param_2; 7 | param_1[2] = 0; 8 | param_1[4] = 0; 9 | param_1[3] = param_3; 10 | return; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00001910@00001910.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00001910(uint param_1,int param_2) 3 | 4 | { 5 | uint uVar1; 6 | uint *puVar2; 7 | uint *puVar3; 8 | int iVar4; 9 | int iVar5; 10 | uint uVar6; 11 | uint local_a8 [6]; 12 | uint auStack_90 [32]; 13 | 14 | iVar4 = 0; 15 | puVar2 = local_a8; 16 | puVar3 = local_a8; 17 | do { 18 | *(uint *)((int)puVar2 + 0x18) = param_1 >> iVar4 & 1; 19 | puVar2 = (uint *)((int)puVar2 + 4); 20 | iVar4 = iVar4 + 1; 21 | } while (iVar4 < 0x20); 22 | iVar4 = 0; 23 | do { 24 | *puVar3 = param_2 >> iVar4 & 1; 25 | puVar3 = puVar3 + 1; 26 | iVar4 = iVar4 + 1; 27 | } while (iVar4 < 6); 28 | iVar4 = 0; 29 | do { 30 | iVar5 = 0; 31 | uVar6 = 1; 32 | uVar1 = 0; 33 | do { 34 | if ((uVar1 & uVar6) != 0) { 35 | if ((uVar6 & 1 << iVar4) != 0) { 36 | local_a8[iVar4] = auStack_90[iVar5] ^ local_a8[iVar4]; 37 | } 38 | iVar5 = iVar5 + 1; 39 | } 40 | uVar1 = uVar1 + 1; 41 | uVar6 = uVar6 + 1; 42 | } while ((int)uVar6 < 0x27); 43 | iVar4 = iVar4 + 1; 44 | } while (iVar4 < 6); 45 | iVar4 = 0; 46 | do { 47 | iVar4 = iVar4 + 1; 48 | } while (iVar4 < 6); 49 | return; 50 | } 51 | 52 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000198e@0000198e.c: -------------------------------------------------------------------------------- 1 | 2 | uint FUN_0000198e(uint param_1) 3 | 4 | { 5 | return (int)(param_1 & 0x400) >> 5 | 6 | (int)(param_1 & 0x100) >> 4 | 7 | (int)(param_1 & 0x40) >> 3 | 8 | (int)(param_1 & 0x10) >> 2 | (int)(param_1 & 4) >> 1 | param_1 & 1; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000019c0@000019c0.c: -------------------------------------------------------------------------------- 1 | 2 | float FUN_000019c0(float param_1,undefined4 param_2,int param_3) 3 | 4 | { 5 | float fVar1; 6 | 7 | fVar1 = (float)thunk_FUN_0000086c((uint)param_1,param_2,param_3); 8 | if (fVar1 < param_1) { 9 | fVar1 = fVar1 + 12.0; 10 | } 11 | return fVar1; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00001bb8@00001bb8.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00001bb8(undefined4 param_1,uint param_2,undefined4 param_3) 3 | 4 | { 5 | int iVar1; 6 | int iVar2; 7 | bool bVar3; 8 | undefined3 extraout_var; 9 | int unaff_gp; 10 | 11 | iVar1 = *(int *)(unaff_gp + 0x3ec); 12 | if (iVar1 != 0) { 13 | iVar2 = *(int *)(unaff_gp + 0x3d8); 14 | *(undefined4 *)(&DAT_00002db8 + unaff_gp) = 1; 15 | if (iVar2 != 7) { 16 | _write_to_stdout(&LAB_00001c00,param_2,param_3,iVar2,1,iVar1); 17 | bVar3 = FUN_0000a7d8(); 18 | if (CONCAT31(extraout_var,bVar3) == 0) { 19 | *(undefined4 *)(&DAT_00002db0 + unaff_gp) = 0xf01; 20 | } 21 | else { 22 | *(undefined4 *)(&DAT_00002db0 + unaff_gp) = 0xf06; 23 | } 24 | } 25 | } 26 | return; 27 | } 28 | 29 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00001c04@00001c04.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00001c04(byte *param_1,uint param_2,uint param_3) 3 | 4 | { 5 | byte bVar1; 6 | uint uVar2; 7 | uint *puVar3; 8 | int iVar4; 9 | uint uVar5; 10 | int unaff_gp; 11 | 12 | uVar2 = FUN_00001d7e((int)param_1,param_2,param_3); 13 | uVar2 = uVar2 >> 0x14 & 0x3ff; 14 | uVar5 = **(uint **)(param_1 + 0x2c) & 0x3ff; 15 | iVar4 = 1; 16 | if (uVar2 <= uVar5) { 17 | iVar4 = -1; 18 | } 19 | FUN_00002378((char *)param_1); 20 | if (uVar2 != uVar5) { 21 | puVar3 = *(uint **)(param_1 + 0x2c); 22 | do { 23 | uVar5 = uVar5 + iVar4; 24 | *puVar3 = uVar5 & 0x3ff | *puVar3 & 0xfffffc00 | 0x5a000000; 25 | } while (uVar2 != uVar5); 26 | } 27 | FUN_000026b6(); 28 | bVar1 = *param_1; 29 | *(uint *)(&LAB_00003170 + (uint)bVar1 * 8 + unaff_gp) = param_2; 30 | *(uint *)((int)(&LAB_00003170 + (uint)bVar1 * 8 + unaff_gp) + 4) = param_3; 31 | return; 32 | } 33 | 34 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00001c60@00001c60.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00001c60(uint param_1,uint param_2,uint param_3,undefined4 param_4,undefined4 param_5, 3 | undefined4 param_6) 4 | 5 | { 6 | undefined4 extraout_r3; 7 | undefined4 extraout_r3_00; 8 | undefined4 extraout_r3_01; 9 | undefined4 extraout_r4; 10 | undefined4 extraout_r4_00; 11 | undefined4 extraout_r4_01; 12 | undefined4 extraout_r5; 13 | undefined4 extraout_r5_00; 14 | undefined4 extraout_r5_01; 15 | undefined auStack_38 [16]; 16 | undefined auStack_28 [16]; 17 | 18 | FUN_0000ca88(param_1,1,(int)auStack_28,param_4,param_5,param_6); 19 | FUN_0000ca88(param_1,2,(int)auStack_38,extraout_r3,extraout_r4,extraout_r5); 20 | FUN_0000ccee(param_1,param_2,param_3,(int)auStack_28,(int)auStack_38); 21 | FUN_0000cac2(param_1,2,(int)auStack_38,extraout_r3_00,extraout_r4_00,extraout_r5_00); 22 | FUN_0000cac2(param_1,1,(int)auStack_28,extraout_r3_01,extraout_r4_01,extraout_r5_01); 23 | FUN_000026b6(); 24 | return; 25 | } 26 | 27 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00001cae@00001cae.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Removing unreachable block (ram,0x00001d10) */ 3 | /* WARNING: Removing unreachable block (ram,0x00001d28) */ 4 | 5 | void FUN_00001cae(int param_1,uint param_2,uint param_3,ulonglong *param_4,uint *param_5) 6 | 7 | { 8 | ulonglong *puVar1; 9 | ulonglong uVar2; 10 | uint uVar3; 11 | uint uVar4; 12 | ulonglong uVar5; 13 | 14 | if (param_3 == 0 && param_2 == 54000000) { 15 | *(undefined4 *)param_4 = 54000000; 16 | *(undefined4 *)((int)param_4 + 4) = 0; 17 | *param_5 = 1; 18 | } 19 | else { 20 | puVar1 = (ulonglong *)(*(int *)(param_1 + 0xc) + 0xc); 21 | uVar4 = *(uint *)(*(int *)(param_1 + 0xc) + 0x10); 22 | uVar2 = *puVar1; 23 | uVar3 = uVar4 >> 3; 24 | uVar4 = *(uint *)puVar1 >> 3 | uVar4 << 0x1d; 25 | if ((param_3 <= uVar3) && ((param_3 != uVar3 || (param_2 <= uVar4)))) { 26 | param_2 = uVar4; 27 | param_3 = uVar3; 28 | } 29 | uVar5 = FUN_0000039c(param_2,param_3,2,0); 30 | uVar4 = 2; 31 | *param_5 = 2; 32 | if (uVar5 < uVar2) { 33 | do { 34 | uVar4 = uVar4 + 2; 35 | uVar5 = FUN_0000039c(uVar4,0,param_2,param_3); 36 | } while (uVar5 < uVar2); 37 | *param_5 = uVar4; 38 | } 39 | *param_4 = uVar5; 40 | } 41 | return; 42 | } 43 | 44 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00001d34@00001d34.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Removing unreachable block (ram,0x00001d5a) */ 3 | /* WARNING: Removing unreachable block (ram,0x00001d72) */ 4 | 5 | void FUN_00001d34(int param_1,uint param_2,int param_3,ulonglong *param_4,uint *param_5) 6 | 7 | { 8 | ulonglong uVar1; 9 | uint uVar2; 10 | int iVar3; 11 | ulonglong uVar4; 12 | 13 | iVar3 = *(int *)(param_1 + 0xc); 14 | uVar2 = 2; 15 | *param_5 = 2; 16 | uVar1 = *(ulonglong *)(iVar3 + 0xc); 17 | uVar4 = FUN_0000039c(param_2,param_3,2,0); 18 | if (uVar4 < uVar1) { 19 | do { 20 | uVar2 = uVar2 + 1; 21 | uVar4 = FUN_0000039c(uVar2,0,param_2,param_3); 22 | } while (uVar4 < uVar1); 23 | *param_5 = uVar2; 24 | } 25 | *param_4 = uVar4; 26 | return; 27 | } 28 | 29 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00001d7e@00001d7e.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00001d7e(int param_1,uint param_2,uint param_3) 3 | 4 | { 5 | float fVar1; 6 | float fVar2; 7 | uint uVar3; 8 | ulonglong uVar4; 9 | 10 | uVar3 = *(uint *)(param_1 + 0x54); 11 | if (uVar3 == 0) { 12 | uVar3 = 1; 13 | } 14 | uVar4 = FUN_00000224(54000000,0,uVar3,0); 15 | fVar1 = (float)FUN_0000011a((uint)uVar4,(uint)(uVar4 >> 0x20)); 16 | fVar2 = (float)FUN_0000011a(param_2,param_3); 17 | FUN_0000b824(fVar2 / fVar1,0x14); 18 | return; 19 | } 20 | 21 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00001db6@00001db6.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00001db6(int param_1,undefined4 *param_2,undefined4 *param_3) 3 | 4 | { 5 | if (param_1 == 0x16) { 6 | *param_2 = 0xb; 7 | LAB_00001de2: 8 | *param_3 = 0xc; 9 | return; 10 | } 11 | if (param_1 < 0x17) { 12 | if (param_1 == 1) { 13 | *param_2 = 0xc; 14 | goto LAB_00001dec; 15 | } 16 | } 17 | else { 18 | if (param_1 == 0x1a) { 19 | *param_2 = 4; 20 | *param_3 = 0; 21 | return; 22 | } 23 | if (param_1 == 0x1b) { 24 | *param_2 = 6; 25 | goto LAB_00001de2; 26 | } 27 | } 28 | *param_2 = 4; 29 | LAB_00001dec: 30 | *param_3 = 8; 31 | return; 32 | } 33 | 34 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00001df2@00001df2.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00001df2(void) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | if (*(int *)(unaff_gp + 100) != 0) { 8 | *(int *)(unaff_gp + 0x68) = unaff_gp + 0xb18; 9 | *(int *)(unaff_gp + 0xfc) = unaff_gp + 0x1500; 10 | *(undefined4 *)(unaff_gp + 0x6c) = 0x19; 11 | return; 12 | } 13 | *(int *)(unaff_gp + 0x68) = unaff_gp + 0x604; 14 | *(int *)(unaff_gp + 0xfc) = (int)(&LAB_000014d8 + unaff_gp); 15 | *(undefined4 *)(unaff_gp + 0x6c) = 0x19; 16 | return; 17 | } 18 | 19 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00001e3a@00001e3a.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00001e3a(uint param_1) 3 | 4 | { 5 | byte *pbVar1; 6 | undefined4 uVar2; 7 | 8 | pbVar1 = FUN_00001ed0(param_1); 9 | if (pbVar1 == (byte *)0x0) { 10 | uVar2 = 0; 11 | } 12 | else { 13 | uVar2 = *(undefined4 *)(pbVar1 + 0x24); 14 | } 15 | return uVar2; 16 | } 17 | 18 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00001e54@00001e54.c: -------------------------------------------------------------------------------- 1 | 2 | ulonglong FUN_00001e54(byte *param_1,uint param_2) 3 | 4 | { 5 | byte *pbVar1; 6 | uint uVar2; 7 | int iVar3; 8 | uint uVar4; 9 | uint uVar5; 10 | int unaff_gp; 11 | ulonglong uVar6; 12 | 13 | uVar5 = *(uint *)(param_1 + 0x5c); 14 | uVar4 = 2; 15 | if (*(int *)(param_1 + 0x50) != 2) { 16 | uVar4 = 1; 17 | } 18 | if (uVar5 == 0) { 19 | uVar6 = *(ulonglong *)(&LAB_00003170 + (uint)*param_1 * 8 + unaff_gp); 20 | uVar5 = **(uint **)(param_1 + 100); 21 | } 22 | else { 23 | uVar2 = param_2; 24 | pbVar1 = param_1; 25 | if (uVar5 < param_2) { 26 | pbVar1 = (byte *)0x0; 27 | uVar2 = 0; 28 | } 29 | if (uVar5 < param_2) { 30 | return CONCAT44(uVar2,pbVar1); 31 | } 32 | iVar3 = *(int *)(param_1 + 0x58) + uVar2 * 0x28; 33 | uVar5 = *(uint *)(iVar3 + 0x10); 34 | if (uVar5 == 0) { 35 | return *(ulonglong *)(iVar3 + 0x14); 36 | } 37 | uVar6 = FUN_00000224(*(uint *)(&LAB_00003170 + (uint)*pbVar1 * 8 + unaff_gp), 38 | *(uint *)((int)(&LAB_00003170 + (uint)*pbVar1 * 8 + unaff_gp) + 4),uVar4,0) 39 | ; 40 | } 41 | uVar6 = FUN_00000224((uint)uVar6,(uint)(uVar6 >> 0x20),uVar5,0); 42 | return uVar6; 43 | } 44 | 45 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00001ebe@00001ebe.c: -------------------------------------------------------------------------------- 1 | 2 | bool FUN_00001ebe(char *param_1) 3 | 4 | { 5 | return *param_1 == '\x02' || *param_1 == '\a'; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00001ed0@00001ed0.c: -------------------------------------------------------------------------------- 1 | 2 | byte * FUN_00001ed0(uint param_1) 3 | 4 | { 5 | byte *pbVar1; 6 | int iVar2; 7 | int iVar3; 8 | int unaff_gp; 9 | 10 | if (((int)param_1 < 0x55) && (iVar3 = *(int *)(unaff_gp + 0x6c), 0 < iVar3)) { 11 | iVar2 = 0; 12 | do { 13 | pbVar1 = (byte *)(*(int *)(unaff_gp + 0x68) + iVar2); 14 | if (param_1 == *pbVar1) { 15 | return pbVar1; 16 | } 17 | iVar2 = iVar2 + 0x34; 18 | iVar3 = iVar3 + -1; 19 | } while (0 < iVar3); 20 | } 21 | return (byte *)0x0; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00002378@00002378.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00002378(char *param_1) 3 | 4 | { 5 | bool bVar1; 6 | undefined3 extraout_var; 7 | uint extraout_r3; 8 | int extraout_r5; 9 | 10 | bVar1 = FUN_00001ebe(param_1); 11 | if (CONCAT31(extraout_var,bVar1) == 0) { 12 | **(uint **)(extraout_r5 + 0x28) = extraout_r3 & 0xfffff | 0x5a000000; 13 | } 14 | else { 15 | **(uint **)(extraout_r5 + 0x28) = 16 | (extraout_r3 & 0x3ff) << 10 | 0x5a000000 | (extraout_r3 & 0xfffff) >> 10; 17 | } 18 | return; 19 | } 20 | 21 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00002676@00002676.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_00002676(int param_1) 5 | 6 | { 7 | int iVar1; 8 | 9 | iVar1 = 0; 10 | while (((*(uint *)(param_1 + 0x44) & _DAT_7d202114) == 0 && (iVar1 < 0x65))) { 11 | FUN_0000bf1c(10); 12 | iVar1 = iVar1 + 1; 13 | } 14 | return; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000026a0@000026a0.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_000026a0(void) 5 | 6 | { 7 | _DAT_7d00f008 = 0; 8 | FUN_0000bf1c(10); 9 | _DAT_7d00f004 = 0; 10 | return; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000026b6@000026b6.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | undefined4 FUN_000026b6(void) 5 | 6 | { 7 | return _DAT_7d2000fc; 8 | } 9 | 10 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00002756@00002756.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00002756(int param_1) 3 | 4 | { 5 | FUN_000026c2(param_1); 6 | FUN_0000c35e(param_1); 7 | *(undefined *)(param_1 + 0x10) = 7; 8 | return; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00002a94@00002a94.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_00002a94(void) 3 | 4 | { 5 | undefined4 uVar1; 6 | undefined4 extraout_r2; 7 | undefined4 extraout_r3; 8 | undefined4 extraout_r4; 9 | undefined4 extraout_r5; 10 | int unaff_gp; 11 | uint local_10; 12 | 13 | if (*(int *)(unaff_gp + 200) == 0) { 14 | uVar1 = FUN_00009e48(&local_10); 15 | if (local_10 < 0x4000) { 16 | FUN_00009cdc(uVar1,local_10,extraout_r2,extraout_r3,extraout_r4,extraout_r5); 17 | } 18 | FUN_000018fc((undefined4 *)(unaff_gp + 0x4f34),uVar1,0x4000); 19 | *(undefined4 *)(unaff_gp + 200) = 1; 20 | } 21 | return unaff_gp + 0x4f34; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00002ae0@00002ae0.c: -------------------------------------------------------------------------------- 1 | 2 | bool FUN_00002ae0(char *param_1) 3 | 4 | { 5 | int iVar1; 6 | char *pcVar2; 7 | uint uVar3; 8 | int iVar4; 9 | int iVar5; 10 | undefined4 extraout_r4; 11 | code *pcVar6; 12 | undefined4 extraout_r4_00; 13 | undefined4 uVar7; 14 | undefined4 extraout_r5; 15 | undefined4 extraout_r5_00; 16 | undefined4 uVar8; 17 | int unaff_gp; 18 | bool bVar9; 19 | int local_18; 20 | 21 | bVar9 = false; 22 | iVar1 = FUN_0000b8a2(); 23 | pcVar2 = FUN_0000ddfa(param_1,0x3d); 24 | if (pcVar2 != (char *)0x0) { 25 | uVar3 = FUN_0000b7b6((byte *)(param_1 + 4),(undefined4 *)0x0,0); 26 | iVar4 = FUN_0000b7b6((byte *)(pcVar2 + 1),(undefined4 *)0x0,0); 27 | iVar5 = -1; 28 | uVar7 = extraout_r4; 29 | uVar8 = extraout_r5; 30 | if ((iVar1 != 0) && (*(int *)(unaff_gp + 0xb8) != 0)) { 31 | pcVar6 = *(code **)(*(int *)(unaff_gp + 0xb8) + 0x34); 32 | (*pcVar6)(*(undefined4 *)(unaff_gp + 0xc0),uVar3,&local_18,0,pcVar6); 33 | iVar5 = local_18; 34 | uVar7 = extraout_r4_00; 35 | uVar8 = extraout_r5_00; 36 | } 37 | bVar9 = iVar4 == iVar5; 38 | _write_to_stdout((byte *)s_gpio_d__d__d_00002b54,uVar3,iVar4,iVar5,uVar7,uVar8); 39 | } 40 | return bVar9; 41 | } 42 | 43 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00002c04@00002c04.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_00002c04(int param_1,undefined4 *param_2) 3 | 4 | { 5 | int iVar1; 6 | uint *puVar2; 7 | int iVar3; 8 | int iVar4; 9 | 10 | iVar4 = 0; 11 | *param_2 = 0; 12 | iVar1 = FUN_0000de22((uint *)(param_1 + 0x3d),(uint *)&LAB_00002c70); 13 | if (iVar1 == 0) { 14 | iVar4 = param_1 + 0x288; 15 | } 16 | else { 17 | iVar1 = FUN_0000de22((uint *)(param_1 + 0x3d),(uint *)s_include_00002c68); 18 | if (iVar1 != 0) { 19 | iVar1 = *(int *)(param_1 + 0x18); 20 | iVar3 = 0; 21 | if (0 < iVar1) { 22 | do { 23 | puVar2 = *(uint **)(*(int *)(param_1 + 0x14) + iVar3 * 0x14 + 4); 24 | if (puVar2 != (uint *)0x0) { 25 | iVar1 = FUN_0000de22(puVar2,(uint *)(param_1 + 0x3d)); 26 | if (iVar1 == 0) { 27 | return *(int *)(param_1 + 0x14) + iVar3 * 0x14; 28 | } 29 | iVar1 = *(int *)(param_1 + 0x18); 30 | } 31 | iVar3 = iVar3 + 1; 32 | } while (iVar3 < iVar1); 33 | } 34 | } 35 | } 36 | return iVar4; 37 | } 38 | 39 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00002cec@00002cec.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00002cec(int param_1) 3 | 4 | { 5 | if (param_1 != 10) { 6 | if (param_1 < 0xb) { 7 | if (param_1 != 9) { 8 | return 0; 9 | } 10 | } 11 | else if ((param_1 != 0xd) && (param_1 != 0x20)) { 12 | return 0; 13 | } 14 | } 15 | return 1; 16 | } 17 | 18 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000308c@0000308c.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Removing unreachable block (ram,0x00003632) */ 3 | /* WARNING: Removing unreachable block (ram,0x000034ae) */ 4 | /* WARNING: Removing unreachable block (ram,0x000030a8) */ 5 | /* WARNING: Removing unreachable block (ram,0x000030b2) */ 6 | /* WARNING: Removing unreachable block (ram,0x000030b8) */ 7 | /* WARNING: Removing unreachable block (ram,0x000030d6) */ 8 | /* WARNING: Removing unreachable block (ram,0x000030da) */ 9 | /* WARNING: Removing unreachable block (ram,0x000030fa) */ 10 | /* WARNING: Removing unreachable block (ram,0x00003100) */ 11 | /* WARNING: Removing unreachable block (ram,0x00003164) */ 12 | /* WARNING: Removing unreachable block (ram,0x0000316a) */ 13 | /* WARNING: Removing unreachable block (ram,0x0000362c) */ 14 | /* WARNING: Removing unreachable block (ram,0x000034b4) */ 15 | 16 | void FUN_0000308c(int param_1) 17 | 18 | { 19 | do { 20 | } while( true ); 21 | } 22 | 23 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00003636@00003636.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_00003636(void) 5 | 6 | { 7 | do { 8 | } while ((_DAT_7c020510 & 1) != 0); 9 | do { 10 | } while ((_DAT_7c021110 & 1) != 0); 11 | FUN_0000bf1c(100); 12 | return; 13 | } 14 | 15 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00003656@00003656.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00003656(int param_1,int *param_2) 3 | 4 | { 5 | uint uVar1; 6 | 7 | uVar1 = FUN_00001224(0x1f); 8 | param_2[1] = (uVar1 & 0xff0000) >> 0x10 | 0xb827eb00; 9 | *param_2 = (uVar1 + param_1) * 0x10000; 10 | return; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000367e@0000367e.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000367e(void) 3 | 4 | { 5 | return; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00003680@00003680.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_00003680(int param_1,int param_2,int param_3,uint param_4) 3 | 4 | { 5 | int iVar1; 6 | uint uVar2; 7 | uint uVar3; 8 | int iVar4; 9 | 10 | iVar4 = 0; 11 | do { 12 | if (param_2 == 0) { 13 | iVar1 = 0x40; 14 | } 15 | else { 16 | iVar1 = 0x200; 17 | } 18 | uVar3 = param_4; 19 | if (iVar1 <= (int)param_4) { 20 | if (param_2 == 0) { 21 | uVar3 = 0x40; 22 | } 23 | else { 24 | uVar3 = 0x200; 25 | } 26 | } 27 | FUN_0000e552(param_1,param_2,param_3,uVar3); 28 | iVar1 = FUN_0000433c(param_1,param_2); 29 | param_4 = param_4 - uVar3; 30 | param_3 = param_3 + uVar3; 31 | if ((iVar1 << 0x19) >> 0x19 != 0xc) { 32 | return -1; 33 | } 34 | uVar2 = *(uint *)(param_1 + param_2 * 4 + 0x24); 35 | iVar4 = iVar4 + uVar2; 36 | if ((int)param_4 < 1) { 37 | return iVar4; 38 | } 39 | } while (uVar3 == uVar2); 40 | return iVar4; 41 | } 42 | 43 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000037b2@000037b2.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_000037b2(void) 3 | 4 | { 5 | return; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000039a4@000039a4.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_000039a4(int param_1,uint *param_2) 3 | 4 | { 5 | uint *puVar1; 6 | int iVar2; 7 | int iVar3; 8 | uint local_38 [4]; 9 | int local_28; 10 | 11 | iVar3 = 0; 12 | if (*(short *)(param_1 + 0x30) != 0) { 13 | do { 14 | FUN_00007dca(local_38,(undefined4 *) 15 | ((uint)*(ushort *)(param_1 + 0x2e) * iVar3 + 16 | *(int *)(param_1 + 0x20) + param_1),0x28); 17 | puVar1 = (uint *)FUN_00003a60(param_1,local_38[0]); 18 | iVar2 = FUN_0000de22(puVar1,param_2); 19 | if (iVar2 == 0) { 20 | return local_28 + param_1; 21 | } 22 | iVar3 = iVar3 + 1; 23 | } while (iVar3 < (int)(uint)*(ushort *)(param_1 + 0x30)); 24 | } 25 | return 0; 26 | } 27 | 28 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000039f4@000039f4.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_000039f4(int param_1,undefined4 param_2,undefined4 *param_3) 3 | 4 | { 5 | uint uVar1; 6 | int *piVar2; 7 | int iVar3; 8 | undefined4 *puVar4; 9 | 10 | uVar1 = (uint)*(ushort *)(param_1 + 0x2c); 11 | iVar3 = 0; 12 | if (uVar1 != 0) { 13 | do { 14 | piVar2 = (int *)((uint)*(ushort *)(param_1 + 0x2a) * iVar3 + 15 | *(int *)(param_1 + 0x1c) + param_1); 16 | if (*piVar2 != 0) { 17 | puVar4 = (undefined4 *)(piVar2[2] | 0xc0000000); 18 | if (puVar4 < (undefined4 *)0x2000000) { 19 | return 0xffffffff; 20 | } 21 | uVar1 = piVar2[4]; 22 | if (uVar1 != 0) { 23 | FUN_00007dca(puVar4,(undefined4 *)(piVar2[1] + param_1),uVar1); 24 | uVar1 = piVar2[4]; 25 | } 26 | if (uVar1 < (uint)piVar2[5]) { 27 | FUN_00007e18((undefined4 *)((int)puVar4 + uVar1),0,piVar2[5] - uVar1); 28 | } 29 | uVar1 = (uint)*(ushort *)(param_1 + 0x2c); 30 | } 31 | iVar3 = iVar3 + 1; 32 | } while (iVar3 < (int)uVar1); 33 | } 34 | *param_3 = *(undefined4 *)(param_1 + 0x18); 35 | return 0; 36 | } 37 | 38 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00003a60@00003a60.c: -------------------------------------------------------------------------------- 1 | 2 | undefined * FUN_00003a60(int param_1,uint param_2) 3 | 4 | { 5 | undefined *puVar1; 6 | undefined4 auStack_34 [4]; 7 | int local_24; 8 | uint local_20; 9 | 10 | FUN_00007dca(auStack_34, 11 | (undefined4 *) 12 | (*(int *)(param_1 + 0x20) + 13 | (uint)*(ushort *)(param_1 + 0x2e) * (uint)*(ushort *)(param_1 + 0x32) + param_1), 14 | 0x28); 15 | if ((local_20 < param_2) || (local_24 + param_1 == 0)) { 16 | puVar1 = &DAT_00003aa0; 17 | } 18 | else { 19 | puVar1 = (undefined *)(local_24 + param_1 + param_2); 20 | } 21 | return puVar1; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00003aa2@00003aa2.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00003aa2(uint param_1,int param_2) 3 | 4 | { 5 | undefined4 uVar1; 6 | 7 | if ((((((param_1 & 3) == 0) && (*(char *)(param_1 + 4) == '\x01')) && 8 | (*(char *)(param_1 + 5) == '\x01')) && 9 | ((*(short *)(param_1 + 0x12) == 0x89 && (*(short *)(param_1 + 0x10) == 2)))) && 10 | ((*(ushort *)(param_1 + 0x2c) != 0 && 11 | (((uint)*(ushort *)(param_1 + 0x2a) * (uint)*(ushort *)(param_1 + 0x2c) + 12 | *(int *)(param_1 + 0x1c) + param_1 <= param_2 + param_1 && 13 | ((uint)*(ushort *)(param_1 + 0x2e) * (uint)*(ushort *)(param_1 + 0x30) + 14 | *(int *)(param_1 + 0x20) + param_1 <= param_2 + param_1)))))) { 15 | uVar1 = 0; 16 | } 17 | else { 18 | uVar1 = 0xffffffff; 19 | } 20 | return uVar1; 21 | } 22 | 23 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00003b00@00003b00.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_00003b00(void) 5 | 6 | { 7 | uint uVar1; 8 | uint uVar2; 9 | uint uVar3; 10 | uint uVar4; 11 | uint uVar5; 12 | 13 | uVar5 = _DAT_7c400034; 14 | uVar4 = _DAT_7c400030; 15 | uVar3 = _DAT_7c400024; 16 | uVar2 = _DAT_7c400004; 17 | uVar1 = _DAT_7c400000; 18 | _DAT_7c400000 = _DAT_7c400000 & 0xfffffffe; 19 | _DAT_7c400004 = _DAT_7c400004 & 0xfffffffe; 20 | _DAT_7c400024 = _DAT_7c400024 & 0xfffffffe; 21 | _DAT_7c400030 = _DAT_7c400030 & 0xfffffffe; 22 | _DAT_7c400034 = _DAT_7c400034 & 0xfffffffe; 23 | do { 24 | } while ((uVar1 & 2) != 0); 25 | do { 26 | } while ((uVar2 & 2) != 0); 27 | do { 28 | } while ((uVar3 & 2) != 0); 29 | do { 30 | } while ((uVar4 & 2) != 0); 31 | do { 32 | } while ((uVar5 & 2) != 0); 33 | _DAT_7d200204 = _DAT_7d200204 | 0x5a000080; 34 | return; 35 | } 36 | 37 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00003b5e@00003b5e.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_00003b5e(void) 5 | 6 | { 7 | int unaff_gp; 8 | 9 | _DAT_7d20203c = 0x5a001000; 10 | do { 11 | } while ((_DAT_7c012088 & 2) != 0); 12 | do { 13 | } while ((_DAT_7c01208c & 2) != 0); 14 | _DAT_7d202038 = 0x5a000001; 15 | _DAT_7d200304 = 0x5a000040; 16 | _DAT_7c012088 = _DAT_7c012088 & 0xfffffffe; 17 | _DAT_7c01208c = _DAT_7c01208c & 0xfffffffe; 18 | FUN_000026b6(); 19 | _DAT_7ee02004 = 0x7777; 20 | _DAT_7ee02084 = 0x7777; 21 | _DAT_7ee0210c = 0x7770777; 22 | _DAT_7c01201c = 6; 23 | _DAT_7d2021c8 = 0x5a000011; 24 | if (*(int *)(unaff_gp + 100) == 0) { 25 | _DAT_7c840008 = &DAT_00005555; 26 | } 27 | _DAT_7cfff5d0 = 3; 28 | _DAT_7d1005d0 = 3; 29 | _DAT_7c01200c = 1; 30 | return; 31 | } 32 | 33 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00003c18@00003c18.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Removing unreachable block (ram,0x00003cd6) */ 3 | /* WARNING: Removing unreachable block (ram,0x00003cec) */ 4 | /* WARNING: Removing unreachable block (ram,0x00003cf2) */ 5 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 6 | 7 | void FUN_00003c18(void) 8 | 9 | { 10 | do { 11 | } while ((_DAT_7c890014 & 2) != 0); 12 | do { 13 | } while ((_DAT_7c890018 & 2) != 0); 14 | do { 15 | } while ((_DAT_7c89001c & 2) != 0); 16 | do { 17 | } while ((_DAT_7c890020 & 2) != 0); 18 | do { 19 | } while ((_DAT_7d2021c8 & 0x80) != 0); 20 | do { 21 | } while( true ); 22 | } 23 | 24 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00003d20@00003d20.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | undefined4 FUN_00003d20(int param_1) 5 | 6 | { 7 | int iVar1; 8 | 9 | FUN_0000e48c(); 10 | if (param_1 != 0) { 11 | FUN_0000bf1c(1000000); 12 | } 13 | iVar1 = FUN_0000b8a2(); 14 | (**(code **)(iVar1 + 200))(); 15 | _DAT_7c400020 = _DAT_7c400020 & 0xbfffffff; 16 | _DAT_7d0000d0 = _DAT_7d0000d0 | 0x48000; 17 | _DAT_7c4f0210 = _DAT_7c4f0210 & 0xffffffcf | 4; 18 | _DAT_7c4f0204 = _DAT_7c4f0204 & 0x7fffffff; 19 | FUN_0000e48c(); 20 | FUN_0000bf1c(10000); 21 | FUN_0000e320(param_1); 22 | return 0; 23 | } 24 | 25 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00004052@00004052.c: -------------------------------------------------------------------------------- 1 | 2 | bool FUN_00004052(int param_1) 3 | 4 | { 5 | return *(char *)(param_1 + 7) == '\0'; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00004060@00004060.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_00004060(int param_1) 3 | 4 | { 5 | int iVar1; 6 | 7 | if (*(char *)(param_1 + 7) == '\0') { 8 | iVar1 = 0; 9 | } 10 | else { 11 | *(char *)(param_1 + 7) = *(char *)(param_1 + 7) + -1; 12 | iVar1 = (int)*(char *)(param_1 + (uint)*(byte *)(param_1 + 6)); 13 | *(byte *)(param_1 + 6) = *(byte *)(param_1 + 6) + 1; 14 | } 15 | return iVar1; 16 | } 17 | 18 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00004088@00004088.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00004088(int param_1,undefined param_2) 3 | 4 | { 5 | byte bVar1; 6 | int iVar2; 7 | undefined4 uVar3; 8 | 9 | bVar1 = *(byte *)(param_1 + 7); 10 | uVar3 = 0; 11 | if (bVar1 == 6) { 12 | uVar3 = 0xffffffff; 13 | } 14 | else { 15 | iVar2 = FUN_000003bc((uint)*(byte *)(param_1 + 6) + (uint)bVar1,6); 16 | *(undefined *)(param_1 + iVar2) = param_2; 17 | *(byte *)(param_1 + 7) = bVar1 + 1; 18 | } 19 | return uVar3; 20 | } 21 | 22 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000040b8@000040b8.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_000040b8(undefined4 param_1) 3 | 4 | { 5 | int extraout_r1; 6 | int iVar1; 7 | int unaff_gp; 8 | 9 | iVar1 = *(int *)(unaff_gp + 0x30); 10 | if (iVar1 == 0) { 11 | *(undefined4 *)(unaff_gp + 0x30) = 1; 12 | FUN_00000686(); 13 | iVar1 = extraout_r1; 14 | } 15 | thunk_FUN_00000482(param_1,iVar1); 16 | return; 17 | } 18 | 19 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000040f8@000040f8.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_000040f8(int *param_1) 3 | 4 | { 5 | undefined4 uVar1; 6 | char *pcVar2; 7 | 8 | uVar1 = 10; 9 | pcVar2 = (char *)*param_1; 10 | if (*pcVar2 == '0') { 11 | uVar1 = 8; 12 | if ((pcVar2[1] == 'x') || (pcVar2[1] == 'X')) { 13 | uVar1 = 0x10; 14 | pcVar2 = pcVar2 + 2; 15 | } 16 | } 17 | *param_1 = (int)pcVar2; 18 | return uVar1; 19 | } 20 | 21 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000411e@0000411e.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_0000411e(char *param_1) 3 | 4 | { 5 | int iVar1; 6 | 7 | iVar1 = 0x80000; 8 | if (*param_1 == -0x11) { 9 | iVar1 = 0x10000 << ((byte)param_1[2] & 0xf); 10 | } 11 | else if (*param_1 == '\x1f') { 12 | iVar1 = ((byte)param_1[1] & 0x1f) << 0x11; 13 | } 14 | return iVar1; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00004148@00004148.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_00004148(void) 5 | 6 | { 7 | uint uVar1; 8 | uint extraout_r1; 9 | ulonglong uVar2; 10 | 11 | if ((_DAT_7d202008 & 0xf) == 1) { 12 | FUN_0000aaa0(); 13 | } 14 | else { 15 | uVar1 = FUN_00001e3a(1); 16 | uVar2 = FUN_00000224(uVar1,extraout_r1,1000000,0); 17 | FUN_0000011a((uint)uVar2,(uint)(uVar2 >> 0x20)); 18 | } 19 | return; 20 | } 21 | 22 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00004176@00004176.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00004176(undefined4 param_1,undefined4 *param_2) 3 | 4 | { 5 | int iVar1; 6 | undefined4 uVar2; 7 | int iVar3; 8 | 9 | switch(param_1) { 10 | default: 11 | iVar3 = 0x57; 12 | break; 13 | case 1: 14 | iVar3 = 0x59; 15 | break; 16 | case 2: 17 | iVar3 = 0x5b; 18 | } 19 | iVar1 = FUN_0000b8a2(); 20 | uVar2 = (**(code **)(iVar1 + 0x84))(iVar3,*(code **)(iVar1 + 0x84)); 21 | *param_2 = uVar2; 22 | iVar1 = FUN_0000b8a2(); 23 | uVar2 = (**(code **)(iVar1 + 0x84))(iVar3 + 1); 24 | param_2[1] = uVar2; 25 | return; 26 | } 27 | 28 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000042bc@000042bc.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | undefined4 5 | FUN_000042bc(undefined4 *param_1,uint param_2,uint *param_3,undefined4 param_4,undefined4 param_5, 6 | undefined4 param_6) 7 | 8 | { 9 | undefined4 *puVar1; 10 | uint uVar2; 11 | uint uVar3; 12 | undefined4 local_20; 13 | 14 | uVar3 = 0; 15 | if ((_DAT_7d208000 & 0x1fff) == 0) { 16 | FUN_00009cdc(param_1,param_2,param_3,0,param_5,param_6); 17 | } 18 | while (uVar3 < param_2) { 19 | uVar2 = param_2 - uVar3; 20 | if (0x40 < uVar2) { 21 | uVar2 = 0x40; 22 | } 23 | uVar3 = uVar3 + uVar2; 24 | while (puVar1 = param_1, (_DAT_7d208024 & 0xff) < 0x10) { 25 | FUN_0000bf1c(0x32); 26 | } 27 | for (; 4 < (int)uVar2; uVar2 = uVar2 - 4) { 28 | local_20 = _DAT_7d208020; 29 | FUN_00007dca(puVar1,&local_20,4); 30 | puVar1 = puVar1 + 1; 31 | } 32 | param_1 = puVar1; 33 | if (0 < (int)uVar2) { 34 | param_1 = (undefined4 *)((int)puVar1 + uVar2); 35 | local_20 = _DAT_7d208020; 36 | FUN_00007dca(puVar1,&local_20,uVar2); 37 | } 38 | } 39 | *param_3 = param_2; 40 | return 0; 41 | } 42 | 43 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000433c@0000433c.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_0000433c(int param_1,int param_2) 3 | 4 | { 5 | bool bVar1; 6 | undefined3 extraout_var; 7 | int iVar2; 8 | undefined3 extraout_var_00; 9 | int iVar3; 10 | int iVar4; 11 | uint local_18; 12 | 13 | iVar4 = param_1 + param_2 * 8; 14 | bVar1 = FUN_00004052(iVar4 + 0x254); 15 | iVar2 = CONCAT31(extraout_var,bVar1); 16 | do { 17 | if (iVar2 == 0) { 18 | iVar2 = FUN_00004060(iVar4 + 0x254); 19 | return iVar2; 20 | } 21 | while( true ) { 22 | iVar2 = FUN_000019d4(param_1,&local_18); 23 | iVar3 = (iVar2 << 0x19) >> 0x19; 24 | if (iVar3 == 0) break; 25 | if (param_2 == local_18 || local_18 == 0xffffffff) { 26 | return iVar3; 27 | } 28 | iVar2 = FUN_00004088(param_1 + local_18 * 8 + 0x254,(char)((iVar2 << 0x19) >> 0x19)); 29 | if (iVar2 < 0) { 30 | return -1; 31 | } 32 | } 33 | bVar1 = FUN_00004052(iVar4 + 0x254); 34 | iVar2 = CONCAT31(extraout_var_00,bVar1); 35 | } while( true ); 36 | } 37 | 38 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000043a6@000043a6.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_000043a6(int param_1,uint *param_2) 3 | 4 | { 5 | FUN_00004176(param_1,param_2); 6 | if (((*param_2 == 0) && (param_2[1] == 0)) || 7 | (((*param_2 & 0xffff0000) == 0xffff0000 && (param_2[1] == 0xffffffff)))) { 8 | FUN_0000440a(param_1,param_2); 9 | } 10 | if (((*param_2 == 0) && (param_2[1] == 0)) || 11 | (((*param_2 & 0xffff0000) == 0xffff0000 && (param_2[1] == 0xffffffff)))) { 12 | FUN_00003656(param_1,(int *)param_2); 13 | } 14 | return; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000440a@0000440a.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000440a(undefined4 param_1,undefined4 *param_2) 3 | 4 | { 5 | int iVar1; 6 | undefined4 uVar2; 7 | int iVar3; 8 | 9 | switch(param_1) { 10 | default: 11 | iVar3 = 0x32; 12 | break; 13 | case 1: 14 | iVar3 = 0x34; 15 | break; 16 | case 2: 17 | iVar3 = 0x36; 18 | } 19 | iVar1 = FUN_0000b8a2(); 20 | uVar2 = (**(code **)(iVar1 + 0x84))(iVar3,*(code **)(iVar1 + 0x84)); 21 | *param_2 = uVar2; 22 | iVar1 = FUN_0000b8a2(); 23 | uVar2 = (**(code **)(iVar1 + 0x84))(iVar3 + 1); 24 | param_2[1] = uVar2; 25 | return; 26 | } 27 | 28 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000444c@0000444c.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000444c(uint param_1) 3 | 4 | { 5 | undefined4 uVar1; 6 | 7 | uVar1 = 0xffffffff; 8 | if (param_1 < 0x36) { 9 | uVar1 = 0; 10 | } 11 | return uVar1; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000452a@0000452a.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000452a(int param_1) 3 | 4 | { 5 | int unaff_gp; 6 | int local_c; 7 | int local_8; 8 | 9 | FUN_00004590(param_1,&local_8,&local_c); 10 | FUN_0000c4fa(*(int *)(&DAT_00005410 + local_8 * 4 + unaff_gp),local_c * 8 + 4); 11 | return; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00004554@00004554.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00004554(int param_1,undefined4 param_2) 3 | 4 | { 5 | int unaff_gp; 6 | int local_10; 7 | int local_c; 8 | 9 | FUN_00004590(param_1,&local_c,&local_10); 10 | FUN_0000c61a(*(int *)(&DAT_00005410 + local_c * 4 + unaff_gp),local_10 * 8 + 4,param_2); 11 | return; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00004590@00004590.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00004590(int param_1,int *param_2,int *param_3) 3 | 4 | { 5 | int iVar1; 6 | 7 | if (param_1 < DAT_0000f80c) { 8 | iVar1 = 0; 9 | } 10 | else if (param_1 < DAT_0000f810) { 11 | iVar1 = 1; 12 | } 13 | else { 14 | iVar1 = 2; 15 | } 16 | *param_2 = iVar1; 17 | *param_3 = param_1 - (&DAT_0000f808)[iVar1]; 18 | return; 19 | } 20 | 21 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00004614@00004614.c: -------------------------------------------------------------------------------- 1 | 2 | undefined * FUN_00004614(void) 3 | 4 | { 5 | return &DAT_0000f2fc; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00004778@00004778.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00004778(int param_1) 3 | 4 | { 5 | int unaff_gp; 6 | int local_c; 7 | int local_8; 8 | 9 | FUN_00004590(param_1,&local_8,&local_c); 10 | FUN_0000c4fa(*(int *)(&DAT_0000541c + local_8 * 4 + unaff_gp),local_c * 4 + 4); 11 | return; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000047a2@000047a2.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_000047a2(int param_1,undefined4 param_2) 3 | 4 | { 5 | int unaff_gp; 6 | int local_10; 7 | int local_c; 8 | 9 | FUN_00004590(param_1,&local_c,&local_10); 10 | FUN_0000c61a(*(int *)(&DAT_0000541c + local_c * 4 + unaff_gp),local_10 * 4 + 4,param_2); 11 | return; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000047d0@000047d0.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_000047d0(uint param_1) 3 | 4 | { 5 | int iVar1; 6 | undefined4 uVar2; 7 | uint local_c; 8 | uint *local_8; 9 | 10 | iVar1 = FUN_000047fc(param_1,&local_c,(int *)0x0,(int *)0x0,&local_8,(undefined4 *)0x0); 11 | if ((iVar1 != 0) || (uVar2 = 1, (*local_8 & 1 << (local_c & 0x1f)) == 0)) { 12 | uVar2 = 0; 13 | } 14 | return uVar2; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000498a@0000498a.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000498a(undefined4 param_1,uint param_2) 3 | 4 | { 5 | int iVar1; 6 | uint uVar2; 7 | uint uVar3; 8 | int extraout_r2; 9 | uint uVar4; 10 | int local_1c; 11 | int iStack_18; 12 | 13 | iVar1 = FUN_0000444c(param_2); 14 | if (iVar1 != 0) { 15 | return 0xffffffff; 16 | } 17 | FUN_00004590(param_2,&iStack_18,&local_1c); 18 | uVar2 = FUN_00004778(param_2); 19 | if (extraout_r2 == 0) { 20 | uVar3 = FUN_00004cc6(param_2); 21 | uVar3 = uVar3 & ~(1 << local_1c); 22 | } 23 | else { 24 | if (extraout_r2 != 1) { 25 | if (extraout_r2 == 3) { 26 | uVar4 = 4; 27 | } 28 | else { 29 | uVar4 = extraout_r2 - 4; 30 | } 31 | if ((int)uVar4 < 0) { 32 | return 0xffffffff; 33 | } 34 | uVar4 = uVar4 & 0x1f; 35 | goto LAB_000049f4; 36 | } 37 | uVar3 = FUN_00004cc6(param_2); 38 | uVar3 = uVar3 | 1 << local_1c; 39 | } 40 | uVar4 = 5; 41 | FUN_00004cea(param_2,uVar3); 42 | LAB_000049f4: 43 | FUN_000047a2(param_2,uVar2 & 0xffffff7f | 0x40); 44 | uVar2 = FUN_0000452a(param_2); 45 | FUN_00004554(param_2,uVar2 & 0xffffffe0 | uVar4); 46 | return 0; 47 | } 48 | 49 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00004ad4@00004ad4.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00004ad4(uint param_1,int param_2) 3 | 4 | { 5 | int iVar1; 6 | uint local_10; 7 | uint *local_c; 8 | 9 | iVar1 = FUN_000047fc(param_1,&local_10,(int *)0x0,(int *)0x0,&local_c,(undefined4 *)0x0); 10 | if (iVar1 == 0) { 11 | if (param_2 == 0) { 12 | *local_c = *local_c & ~(1 << (local_10 & 0x1f)); 13 | } 14 | else { 15 | *local_c = *local_c | 1 << (local_10 & 0x1f); 16 | } 17 | } 18 | return; 19 | } 20 | 21 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00004cc6@00004cc6.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00004cc6(int param_1) 3 | 4 | { 5 | int unaff_gp; 6 | int iStack_c; 7 | int local_8; 8 | 9 | FUN_00004590(param_1,&local_8,&iStack_c); 10 | FUN_0000c4fa(*(int *)(&DAT_00005428 + local_8 * 4 + unaff_gp),4); 11 | return; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00004cea@00004cea.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00004cea(int param_1,undefined4 param_2) 3 | 4 | { 5 | int unaff_gp; 6 | int iStack_10; 7 | int local_c; 8 | 9 | FUN_00004590(param_1,&local_c,&iStack_10); 10 | FUN_0000c61a(*(int *)(&DAT_00005428 + local_c * 4 + unaff_gp),4,param_2); 11 | return; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00004d12@00004d12.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00004d12(int param_1) 3 | 4 | { 5 | int unaff_gp; 6 | int iStack_c; 7 | int local_8; 8 | 9 | FUN_00004590(param_1,&local_8,&iStack_c); 10 | FUN_0000c4fa(*(int *)(&DAT_00005428 + local_8 * 4 + unaff_gp),0); 11 | return; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00004d36@00004d36.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00004d36(int param_1,undefined4 param_2) 3 | 4 | { 5 | int unaff_gp; 6 | int iStack_10; 7 | int local_c; 8 | 9 | FUN_00004590(param_1,&local_c,&iStack_10); 10 | FUN_0000c61a(*(int *)(&DAT_00005428 + local_c * 4 + unaff_gp),0,param_2); 11 | return; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00004d5e@00004d5e.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00004d5e(int param_1) 3 | 4 | { 5 | int unaff_gp; 6 | int iStack_c; 7 | int local_8; 8 | 9 | FUN_00004590(param_1,&local_8,&iStack_c); 10 | FUN_0000c4fa(*(int *)(&DAT_00005428 + local_8 * 4 + unaff_gp),8); 11 | return; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00004d82@00004d82.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00004d82(undefined4 param_1,uint param_2,uint param_3) 3 | 4 | { 5 | int iVar1; 6 | uint uVar2; 7 | undefined4 uVar3; 8 | 9 | iVar1 = FUN_0000444c(param_2); 10 | uVar3 = 0; 11 | if ((iVar1 == 0) && ((int)param_3 < 4)) { 12 | if (param_3 == 3) { 13 | param_3 = (uint)(byte)(&DAT_0000f170)[param_2]; 14 | } 15 | uVar2 = FUN_00004778(param_2); 16 | uVar2 = uVar2 & 0xfffffff3; 17 | if (param_3 == 2) { 18 | uVar2 = uVar2 | 8; 19 | } 20 | else if (param_3 == 1) { 21 | uVar2 = uVar2 | 4; 22 | } 23 | FUN_000047a2(param_2,uVar2); 24 | } 25 | else { 26 | uVar3 = 0xffffffff; 27 | } 28 | return uVar3; 29 | } 30 | 31 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00004dcc@00004dcc.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_00004dcc(int param_1,int param_2) 3 | 4 | { 5 | int iVar1; 6 | int unaff_gp; 7 | 8 | iVar1 = 0; 9 | switch(*(undefined *)(param_2 + 1)) { 10 | case 0: 11 | FUN_0000e598(param_1,0,(undefined4 *)(unaff_gp + 0x1d98),2); 12 | break; 13 | default: 14 | iVar1 = -1; 15 | break; 16 | case 6: 17 | iVar1 = FUN_000041b4(param_1,param_2); 18 | } 19 | if (iVar1 == 0) { 20 | iVar1 = FUN_0000433c(param_1,0); 21 | if ((iVar1 << 0x19) >> 0x19 == 0xb) { 22 | FUN_0000e552(param_1,0,param_1 + 8,8); 23 | iVar1 = FUN_0000433c(param_1,0); 24 | if ((iVar1 << 0x19) >> 0x19 == 0xc) { 25 | return 0; 26 | } 27 | } 28 | iVar1 = -1; 29 | } 30 | return iVar1; 31 | } 32 | 33 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00004e3e@00004e3e.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | undefined4 FUN_00004e3e(int param_1,int param_2) 5 | 6 | { 7 | int iVar1; 8 | 9 | if (*(char *)(param_2 + 1) == '\x05') { 10 | _DAT_7c480800 = (*(byte *)(param_2 + 2) & 0x7f) << 4 | _DAT_7c480800 & 0xfffff80f; 11 | FUN_0000e598(param_1,0,(undefined4 *)(param_1 + 8),0); 12 | iVar1 = FUN_0000433c(param_1,0); 13 | if ((iVar1 << 0x19) >> 0x19 == 0xb) { 14 | return 0; 15 | } 16 | } 17 | else if (*(char *)(param_2 + 1) == '\t') { 18 | FUN_0000e598(param_1,0,(undefined4 *)(param_1 + 8),0); 19 | iVar1 = FUN_0000433c(param_1,0); 20 | if ((iVar1 << 0x19) >> 0x19 == 0xb) { 21 | FUN_0000e552(param_1,1,param_1 + 0x3d,*(uint *)(param_1 + 0x240)); 22 | *(undefined *)(param_1 + 0x248) = 4; 23 | return 0; 24 | } 25 | } 26 | return 0xffffffff; 27 | } 28 | 29 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00004ec4@00004ec4.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_00004ec4(int param_1,ushort *param_2) 3 | 4 | { 5 | byte bVar1; 6 | int iVar2; 7 | int iVar3; 8 | 9 | bVar1 = *(byte *)param_2; 10 | iVar2 = (int)(bVar1 & 0x7f) >> 5; 11 | iVar3 = 0; 12 | if (iVar2 == 0 && (bVar1 & 0xf) == 0) { 13 | if ((bVar1 & 0x80) == 0) { 14 | iVar3 = FUN_00004e3e(param_1,(int)param_2); 15 | } 16 | else { 17 | iVar3 = FUN_00004dcc(param_1,(int)param_2); 18 | } 19 | } 20 | else if (iVar2 == 2) { 21 | iVar3 = FUN_00004f0e(param_1,param_2); 22 | } 23 | FUN_0000e552(param_1,0,param_1 + 8,8); 24 | return iVar3; 25 | } 26 | 27 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00004fc6@00004fc6.c: -------------------------------------------------------------------------------- 1 | 2 | bool FUN_00004fc6(void) 3 | 4 | { 5 | undefined4 *puVar1; 6 | int iVar2; 7 | undefined uStack_15; 8 | undefined4 local_14; 9 | undefined4 local_10; 10 | 11 | puVar1 = (undefined4 *)FUN_00001552(); 12 | local_14 = DAT_0000eec0; 13 | (*(code *)*puVar1)(DAT_0000eec0,(code *)*puVar1); 14 | (*(code *)puVar1[3])(&local_14,&local_10); 15 | (*(code *)puVar1[0xc])(local_10,0x38,(code *)puVar1[0xc]); 16 | iVar2 = (*(code *)puVar1[7])(local_10,&LAB_00001830,1,&uStack_15); 17 | (*(code *)puVar1[4])(local_10); 18 | return iVar2 == 0; 19 | } 20 | 21 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00005014@00005014.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00005014(void) 3 | 4 | { 5 | int iVar1; 6 | undefined *puVar2; 7 | undefined4 extraout_r2; 8 | undefined4 extraout_r3; 9 | undefined4 extraout_r4; 10 | undefined4 extraout_r5; 11 | int unaff_gp; 12 | uint unaff_lr; 13 | 14 | iVar1 = FUN_0000b8a2(); 15 | puVar2 = *(undefined **)(unaff_gp + 0x2d04); 16 | if (puVar2 == (undefined *)0x0) { 17 | puVar2 = &DAT_0001c200; 18 | } 19 | FUN_0000e09e(iVar1,puVar2); 20 | _sprintf_to_stdout((byte *)s_I2C_error____x_0000504c,unaff_lr,extraout_r2,extraout_r3,extraout_r4, 21 | extraout_r5); 22 | FUN_0000e072(); 23 | do { 24 | FUN_0000a332(0x33,0); 25 | } while( true ); 26 | } 27 | 28 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000505c@0000505c.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000505c(undefined4 *param_1) 3 | 4 | { 5 | uint *puVar1; 6 | int iVar2; 7 | 8 | if ((param_1 == (undefined4 *)0x0) || (param_1[1] != 0x49324300)) { 9 | FUN_00005014(); 10 | } 11 | puVar1 = (uint *)*param_1; 12 | *puVar1 = *puVar1 | 0x30; 13 | for (iVar2 = 50000; (puVar1[1] >> 0x1c != 0 && (0 < iVar2)); iVar2 = iVar2 + -1) { 14 | FUN_0000bf1c(1); 15 | puVar1 = (uint *)*param_1; 16 | } 17 | *puVar1 = *puVar1 | 0x30; 18 | if (iVar2 < 0) { 19 | FUN_00005014(); 20 | } 21 | return; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000052a0@000052a0.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_000052a0(int *param_1) 3 | 4 | { 5 | undefined4 *puVar1; 6 | int iVar2; 7 | 8 | if ((param_1 == (int *)0x0) || (param_1[1] != 0x49324300)) { 9 | FUN_00005014(); 10 | } 11 | for (iVar2 = 50000; ((*(uint *)(*param_1 + 4) & 0x20) != 0 && (0 < iVar2)); iVar2 = iVar2 + -1) { 12 | FUN_0000bf1c(1); 13 | } 14 | *(undefined4 *)(*param_1 + 4) = 0x302; 15 | FUN_0000505c(param_1); 16 | puVar1 = (undefined4 *)*param_1; 17 | puVar1[2] = 0; 18 | *puVar1 = 0; 19 | FUN_0000bf1c(10); 20 | if (iVar2 < 0) { 21 | FUN_00005014(); 22 | } 23 | return 0; 24 | } 25 | 26 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000053f2@000053f2.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_000053f2(void) 5 | 6 | { 7 | _DAT_7d208004 = 0; 8 | _DAT_7d208008 = 0; 9 | _DAT_7d208000 = 0x7fff; 10 | return; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00005754@00005754.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_00005754(int param_1) 5 | 6 | { 7 | uint uVar1; 8 | uint uVar2; 9 | int iVar3; 10 | uint *puVar4; 11 | 12 | FUN_0000e28a(); 13 | FUN_0000e2c8(param_1); 14 | _DAT_7c480800 = &DAT_00040800; 15 | _DAT_7c480024 = 0x200; 16 | _DAT_7c480028 = 0x2000200; 17 | puVar4 = (uint *)&DAT_7c480104; 18 | uVar2 = 0x400; 19 | iVar3 = 4; 20 | do { 21 | uVar1 = uVar2 | 0x2000000; 22 | uVar2 = uVar2 + 0x200; 23 | *puVar4 = uVar1; 24 | puVar4 = puVar4 + 8; 25 | iVar3 = iVar3 + -1; 26 | } while (0 < iVar3); 27 | return; 28 | } 29 | 30 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000057a2@000057a2.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_000057a2(undefined4 param_1) 3 | 4 | { 5 | undefined4 uVar1; 6 | 7 | switch(param_1) { 8 | default: 9 | uVar1 = 0; 10 | break; 11 | case 0x33: 12 | case 0x35: 13 | case 0x37: 14 | uVar1 = 1; 15 | } 16 | return uVar1; 17 | } 18 | 19 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000057ba@000057ba.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_000057ba(undefined4 param_1) 3 | 4 | { 5 | undefined4 uVar1; 6 | 7 | switch(param_1) { 8 | default: 9 | uVar1 = 0; 10 | break; 11 | case 0x34: 12 | case 0x35: 13 | uVar1 = 1; 14 | break; 15 | case 0x36: 16 | case 0x37: 17 | uVar1 = 2; 18 | } 19 | return uVar1; 20 | } 21 | 22 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00005930@00005930.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00005930(uint param_1,uint param_2) 3 | 4 | { 5 | uint uVar1; 6 | uint uVar2; 7 | uint uVar3; 8 | uint uVar4; 9 | 10 | uVar3 = 0x80000000; 11 | uVar4 = 0; 12 | uVar1 = 0; 13 | if ((param_2 & 0x80000000) == 0) { 14 | do { 15 | uVar2 = uVar3 << 0x1f; 16 | uVar1 = uVar1 + 1; 17 | uVar3 = uVar3 >> 1; 18 | uVar4 = uVar4 >> 1 | uVar2; 19 | if (0x3f < uVar1) { 20 | return; 21 | } 22 | } while ((uVar3 & param_2) == 0 && (uVar4 & param_1) == 0); 23 | } 24 | return; 25 | } 26 | 27 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00005972@00005972.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00005972(undefined4 *param_1) 3 | 4 | { 5 | code *pcVar1; 6 | int iVar2; 7 | int iVar3; 8 | int unaff_gp; 9 | 10 | iVar2 = 0; 11 | if (0 < *(int *)(&DAT_0000307c + unaff_gp)) { 12 | do { 13 | iVar3 = iVar2 * 0xc; 14 | if (param_1 == *(undefined4 **)((int)&PTR_DAT_00003080 + iVar3 + unaff_gp)) { 15 | FUN_00007e18(param_1,0,*(uint *)(&DAT_00003084 + iVar3 + unaff_gp)); 16 | *(undefined4 *)(&LAB_00003088 + iVar3 + unaff_gp) = 0; 17 | return; 18 | } 19 | iVar2 = iVar2 + 1; 20 | } while (iVar2 < *(int *)(&DAT_0000307c + unaff_gp)); 21 | } 22 | pcVar1 = (code *)swi(0xe); 23 | (*pcVar1)(); 24 | return; 25 | } 26 | 27 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000059bc@000059bc.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_000059bc(undefined4 param_1,uint param_2) 3 | 4 | { 5 | code *pcVar1; 6 | int unaff_gp; 7 | 8 | *(undefined4 *)(&DAT_00003070 + unaff_gp) = param_1; 9 | *(undefined4 *)(&DAT_00003074 + unaff_gp) = 0; 10 | *(undefined4 *)(&DAT_0000307c + unaff_gp) = 0; 11 | *(uint *)(&DAT_00003078 + unaff_gp) = param_2; 12 | if (param_2 < 0x13c8) { 13 | pcVar1 = (code *)swi(0xe); 14 | (*pcVar1)(); 15 | do { 16 | /* WARNING: Do nothing block with infinite loop */ 17 | } while( true ); 18 | } 19 | return; 20 | } 21 | 22 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00006a26@00006a26.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00006a26(int *param_1,int *param_2,int *param_3) 3 | 4 | { 5 | int iVar1; 6 | int iVar2; 7 | 8 | iVar1 = *param_2; 9 | if (*param_3 * iVar1 < 0) { 10 | iVar2 = FUN_00006aaa((int)param_2,(int)param_3); 11 | if (iVar2 < 0) { 12 | FUN_00007842(param_1,param_3,param_2); 13 | *param_1 = -iVar1; 14 | return 0; 15 | } 16 | FUN_00007842(param_1,param_2,param_3); 17 | } 18 | else { 19 | FUN_0000692a(param_1,param_2,param_3); 20 | } 21 | *param_1 = iVar1; 22 | return 0; 23 | } 24 | 25 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00006a70@00006a70.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_00006a70(int param_1) 3 | 4 | { 5 | int iVar1; 6 | uint uVar3; 7 | uint *puVar4; 8 | int iVar5; 9 | uint uVar2; 10 | 11 | iVar5 = *(int *)(param_1 + 4); 12 | if (iVar5 == 0) { 13 | iVar5 = 0; 14 | } 15 | else { 16 | puVar4 = *(uint **)(param_1 + 8); 17 | do { 18 | iVar5 = iVar5 + -1; 19 | if (iVar5 == 0) { 20 | uVar2 = *puVar4; 21 | uVar3 = puVar4[1]; 22 | break; 23 | } 24 | uVar3 = (puVar4 + iVar5 * 2)[1]; 25 | uVar2 = puVar4[iVar5 * 2]; 26 | } while (uVar3 == 0 && uVar2 == 0); 27 | iVar1 = FUN_00005930(uVar2,uVar3); 28 | iVar5 = (0x40 - iVar1) + iVar5 * 0x40; 29 | } 30 | return iVar5; 31 | } 32 | 33 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00006b48@00006b48.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00006b48(int *param_1,uint param_2,int param_3) 3 | 4 | { 5 | uint local_24; 6 | int local_20; 7 | int local_18 [2]; 8 | undefined *local_10; 9 | 10 | local_10 = (undefined *)&local_24; 11 | if (param_3 < 0) { 12 | local_24 = -param_2; 13 | local_20 = ((int)(param_2 | local_24) >> 0x1f) - param_3; 14 | local_18[0] = -1; 15 | } 16 | else { 17 | local_18[0] = 1; 18 | local_24 = param_2; 19 | local_20 = param_3; 20 | } 21 | local_18[1] = 1; 22 | FUN_00006b96(param_1,local_18); 23 | return; 24 | } 25 | 26 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00006c4e@00006c4e.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00006c4e(undefined4 *param_1,undefined4 *param_2) 3 | 4 | { 5 | int *piVar1; 6 | uint uVar2; 7 | uint uVar3; 8 | 9 | if (param_1 != param_2) { 10 | if (param_2[2] == 0) { 11 | FUN_00007450(param_1); 12 | } 13 | else { 14 | uVar2 = param_2[1]; 15 | do { 16 | uVar3 = uVar2; 17 | uVar2 = uVar3 - 1; 18 | if (uVar2 == 0) break; 19 | piVar1 = (int *)(param_2[2] + uVar2 * 8); 20 | } while (piVar1[1] == 0 && *piVar1 == 0); 21 | *param_1 = *param_2; 22 | if ((uint)param_1[1] < uVar3) { 23 | FUN_00007476((int)param_1,uVar3); 24 | } 25 | else { 26 | FUN_00007e18((undefined4 *)(param_1[2] + uVar3 * 8),0,(param_1[1] - uVar3) * 8); 27 | } 28 | FUN_00007dca((undefined4 *)param_1[2],(undefined4 *)param_2[2],uVar2 * 8 + 8); 29 | } 30 | } 31 | return 0; 32 | } 33 | 34 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00007450@00007450.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00007450(undefined4 *param_1) 3 | 4 | { 5 | if (param_1 != (undefined4 *)0x0) { 6 | if ((undefined4 *)param_1[2] != (undefined4 *)0x0) { 7 | FUN_0000798c((undefined4 *)param_1[2],param_1[1]); 8 | FUN_00005972((undefined4 *)param_1[2]); 9 | } 10 | *param_1 = 1; 11 | param_1[1] = 0; 12 | param_1[2] = 0; 13 | } 14 | return; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00007476@00007476.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00007476(int param_1,uint param_2) 3 | 4 | { 5 | undefined4 *puVar1; 6 | undefined4 uVar2; 7 | 8 | if (param_2 < 0x2711) { 9 | if (*(uint *)(param_1 + 4) < param_2) { 10 | puVar1 = (undefined4 *)FUN_00005872(param_2,8); 11 | if (puVar1 == (undefined4 *)0x0) goto LAB_00007496; 12 | if (*(undefined4 **)(param_1 + 8) != (undefined4 *)0x0) { 13 | FUN_00007dca(puVar1,*(undefined4 **)(param_1 + 8),*(int *)(param_1 + 4) << 3); 14 | FUN_0000798c(*(undefined4 **)(param_1 + 8),*(uint *)(param_1 + 4)); 15 | FUN_00005972(*(undefined4 **)(param_1 + 8)); 16 | } 17 | *(uint *)(param_1 + 4) = param_2; 18 | *(undefined4 **)(param_1 + 8) = puVar1; 19 | } 20 | uVar2 = 0; 21 | } 22 | else { 23 | LAB_00007496: 24 | uVar2 = 0xfffffff0; 25 | } 26 | return uVar2; 27 | } 28 | 29 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000074be@000074be.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_000074be(undefined4 *param_1) 3 | 4 | { 5 | *param_1 = 1; 6 | param_1[1] = 0; 7 | param_1[2] = 0; 8 | return; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000074ca@000074ca.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_000074ca(undefined4 *param_1,uint param_2,uint param_3) 3 | 4 | { 5 | uint *puVar1; 6 | undefined4 uVar2; 7 | uint uVar3; 8 | 9 | FUN_00007476((int)param_1,1); 10 | FUN_00007e18((undefined4 *)param_1[2],0,param_1[1] << 3); 11 | uVar3 = param_3; 12 | if ((int)param_3 < 0) { 13 | uVar3 = param_2 | -param_2; 14 | param_2 = -param_2; 15 | uVar3 = ((int)uVar3 >> 0x1f) - param_3; 16 | } 17 | puVar1 = (uint *)param_1[2]; 18 | *puVar1 = param_2; 19 | puVar1[1] = uVar3; 20 | if ((int)param_3 < 0) { 21 | uVar2 = 0xffffffff; 22 | } 23 | else { 24 | uVar2 = 1; 25 | } 26 | *param_1 = uVar2; 27 | return 0; 28 | } 29 | 30 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00007520@00007520.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00007520(int *param_1,int *param_2,int *param_3) 3 | 4 | { 5 | int iVar1; 6 | undefined4 uVar2; 7 | 8 | uVar2 = 0; 9 | iVar1 = FUN_00006b48(param_3,0,0); 10 | if (iVar1 < 0) { 11 | uVar2 = 0xfffffff6; 12 | } 13 | else { 14 | FUN_00006cb2((int *)0x0,param_1,param_2,param_3); 15 | while (iVar1 = FUN_00006b48(param_1,0,0), iVar1 < 0) { 16 | FUN_00006a26(param_1,param_1,param_3); 17 | } 18 | while (iVar1 = FUN_00006b96(param_1,param_3), -1 < iVar1) { 19 | FUN_000078ba(param_1,param_1,param_3); 20 | } 21 | } 22 | return uVar2; 23 | } 24 | 25 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000757e@0000757e.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000757e(int *param_1,int *param_2,undefined4 param_3,undefined4 param_4) 3 | 4 | { 5 | undefined4 local_1c; 6 | undefined4 local_18; 7 | int local_10 [2]; 8 | undefined *local_8; 9 | 10 | local_8 = (undefined *)&local_1c; 11 | local_10[0] = 1; 12 | local_10[1] = 1; 13 | local_1c = param_3; 14 | local_18 = param_4; 15 | FUN_0000759c(param_1,param_2,local_10); 16 | return; 17 | } 18 | 19 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00007672@00007672.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00007672(undefined4 *param_1,undefined4 *param_2,uint param_3) 3 | 4 | { 5 | uint uVar1; 6 | 7 | uVar1 = (uint)((param_3 & 7) != 0) + (param_3 >> 3); 8 | if (uVar1 != param_1[1]) { 9 | FUN_00007450(param_1); 10 | FUN_000074be(param_1); 11 | FUN_00007476((int)param_1,uVar1); 12 | } 13 | FUN_000074ca(param_1,0,0); 14 | if (param_2 != (undefined4 *)0x0) { 15 | FUN_00007dca((undefined4 *)(param_1[2] + (uVar1 * 8 - param_3)),param_2,param_3); 16 | FUN_00009188((uint *)param_1[2],uVar1); 17 | } 18 | return 0; 19 | } 20 | 21 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00007842@00007842.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 * FUN_00007842(undefined4 *param_1,undefined4 *param_2,undefined4 *param_3) 3 | 4 | { 5 | int iVar1; 6 | uint uVar2; 7 | uint *puVar3; 8 | undefined4 auStack_20 [3]; 9 | 10 | iVar1 = FUN_00006aaa((int)param_2,(int)param_3); 11 | if (iVar1 < 0) { 12 | param_2 = (undefined4 *)0xfffffff6; 13 | } 14 | if (-1 < iVar1) { 15 | FUN_000074be(auStack_20); 16 | if (param_1 == param_3) { 17 | FUN_00006c4e(auStack_20,param_3); 18 | param_3 = auStack_20; 19 | } 20 | if (param_1 != param_2) { 21 | FUN_00006c4e(param_1,param_2); 22 | } 23 | param_2 = (undefined4 *)0x0; 24 | *param_1 = 1; 25 | uVar2 = param_3[1]; 26 | puVar3 = (uint *)param_3[2]; 27 | while ((uVar2 != 0 && (puVar3[uVar2 * 2 + -1] == 0 && puVar3[uVar2 * 2 + -2] == 0))) { 28 | uVar2 = uVar2 - 1; 29 | } 30 | FUN_0000971e(uVar2,puVar3,(uint *)param_1[2]); 31 | FUN_00007450(auStack_20); 32 | } 33 | return param_2; 34 | } 35 | 36 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000078ba@000078ba.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_000078ba(int *param_1,int *param_2,int *param_3) 3 | 4 | { 5 | int iVar1; 6 | int iVar2; 7 | 8 | iVar1 = *param_2; 9 | if (*param_3 * iVar1 < 1) { 10 | FUN_0000692a(param_1,param_2,param_3); 11 | } 12 | else { 13 | iVar2 = FUN_00006aaa((int)param_2,(int)param_3); 14 | if (iVar2 < 0) { 15 | FUN_00007842(param_1,param_3,param_2); 16 | *param_1 = -iVar1; 17 | return 0; 18 | } 19 | FUN_00007842(param_1,param_2,param_3); 20 | } 21 | *param_1 = iVar1; 22 | return 0; 23 | } 24 | 25 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00007904@00007904.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00007904(int param_1,undefined4 *param_2,uint param_3) 3 | 4 | { 5 | int iVar1; 6 | uint *puVar2; 7 | int iVar3; 8 | uint uVar4; 9 | uint uVar5; 10 | ulonglong uVar6; 11 | 12 | iVar3 = *(int *)(param_1 + 4); 13 | uVar4 = iVar3 * 8; 14 | if (uVar4 < param_3) { 15 | iVar1 = iVar3 * -8 + param_3; 16 | FUN_00007e18(param_2,0,param_3 + iVar3 * -8); 17 | param_3 = uVar4; 18 | param_2 = (undefined4 *)((int)param_2 + iVar1); 19 | } 20 | else if (param_3 < uVar4) { 21 | iVar3 = *(int *)(param_1 + 8); 22 | uVar5 = param_3; 23 | do { 24 | puVar2 = (uint *)((uVar5 & 0xfffffff8) + iVar3); 25 | uVar6 = FUN_0000036e(*puVar2,puVar2[1],(uVar5 & 7) << 3); 26 | if ((uVar6 & 0xff) != 0) { 27 | return 0xfffffff8; 28 | } 29 | uVar5 = uVar5 + 1; 30 | } while (uVar5 < uVar4); 31 | } 32 | uVar4 = 0; 33 | if (param_3 != 0) { 34 | iVar3 = *(int *)(param_1 + 8); 35 | do { 36 | puVar2 = (uint *)((uVar4 & 0xfffffff8) + iVar3); 37 | uVar6 = FUN_0000036e(*puVar2,puVar2[1],(uVar4 & 7) << 3); 38 | *(char *)((int)param_2 + (param_3 - uVar4) + -1) = (char)uVar6; 39 | uVar4 = uVar4 + 1; 40 | } while (uVar4 < param_3); 41 | } 42 | return 0; 43 | } 44 | 45 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000798c@0000798c.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000798c(undefined4 *param_1,uint param_2) 3 | 4 | { 5 | FUN_00007e18(param_1,0,param_2); 6 | return; 7 | } 8 | 9 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00007994@00007994.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00007994(undefined4 param_1,int param_2) 3 | 4 | { 5 | if (param_2 != 0) { 6 | (*DAT_0000fad4)(param_1,0,param_2,DAT_0000fad4); 7 | } 8 | return; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000079a8@000079a8.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_000079a8(int param_1,undefined4 param_2,undefined4 *param_3) 3 | 4 | { 5 | int iVar1; 6 | undefined4 *extraout_r3; 7 | int iVar2; 8 | uint uVar3; 9 | int aiStack_24 [3]; 10 | 11 | iVar2 = 0; 12 | FUN_000074be(aiStack_24); 13 | FUN_00007672(aiStack_24,extraout_r3,*(uint *)(param_1 + 4)); 14 | iVar1 = FUN_00006b96(aiStack_24,(int *)(param_1 + 8)); 15 | if (-1 < iVar1) { 16 | iVar2 = -4; 17 | } 18 | if (iVar1 < 0) { 19 | uVar3 = *(uint *)(param_1 + 4); 20 | FUN_0000704e(aiStack_24,aiStack_24,(int *)(param_1 + 0x14),(int *)(param_1 + 8), 21 | (int *)(param_1 + 0x68)); 22 | FUN_00007904((int)aiStack_24,param_3,uVar3); 23 | } 24 | FUN_00007450(aiStack_24); 25 | if (iVar2 == 0) { 26 | iVar2 = 0; 27 | } 28 | else { 29 | iVar2 = iVar2 + -0x4280; 30 | } 31 | return iVar2; 32 | } 33 | 34 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00007c54@00007c54.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00007c54(int param_1) 3 | 4 | { 5 | if (param_1 != 0) { 6 | FUN_00007994(param_1,0x6c); 7 | } 8 | return; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00007c64@00007c64.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00007c64(undefined4 *param_1) 3 | 4 | { 5 | FUN_00007e18(param_1,0,0x6c); 6 | return; 7 | } 8 | 9 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00007c6e@00007c6e.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00007c6e(undefined4 *param_1,int param_2) 3 | 4 | { 5 | *param_1 = 0; 6 | param_1[1] = 0; 7 | if (param_2 == 0) { 8 | param_1[2] = 0x6a09e667; 9 | param_1[3] = 0xbb67ae85; 10 | param_1[4] = 0x3c6ef372; 11 | param_1[5] = 0xa54ff53a; 12 | param_1[6] = 0x510e527f; 13 | param_1[7] = 0x9b05688c; 14 | param_1[8] = 0x1f83d9ab; 15 | param_1[9] = 0x5be0cd19; 16 | } 17 | else { 18 | param_1[2] = 0xc1059ed8; 19 | param_1[3] = 0x367cd507; 20 | param_1[4] = 0x3070dd17; 21 | param_1[5] = 0xf70e5939; 22 | param_1[6] = 0xffc00b31; 23 | param_1[7] = 0x68581511; 24 | param_1[8] = 0x64f98fa7; 25 | param_1[9] = 0xbefa4fa4; 26 | } 27 | param_1[0x1a] = param_2; 28 | return 0; 29 | } 30 | 31 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00007d02@00007d02.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_00007d02(uint *param_1,byte *param_2,uint param_3) 3 | 4 | { 5 | int iVar1; 6 | uint uVar2; 7 | uint uVar3; 8 | uint uVar4; 9 | 10 | if (param_3 != 0) { 11 | uVar3 = *param_1 & 0x3f; 12 | uVar2 = *param_1 + param_3; 13 | *param_1 = uVar2; 14 | uVar4 = 0x40 - uVar3; 15 | if (uVar2 < param_3) { 16 | param_1[1] = param_1[1] + 1; 17 | } 18 | if ((uVar3 != 0) && (uVar4 <= param_3)) { 19 | FUN_00007dca((undefined4 *)((int)param_1 + uVar3 + 0x28),(undefined4 *)param_2,uVar4); 20 | iVar1 = FUN_00005c58((int)param_1,(byte *)(param_1 + 10)); 21 | if (iVar1 != 0) { 22 | return iVar1; 23 | } 24 | param_2 = param_2 + uVar4; 25 | param_3 = param_3 - uVar4; 26 | uVar3 = 0; 27 | } 28 | for (; 0x3f < param_3; param_3 = param_3 - 0x40) { 29 | iVar1 = FUN_00005c58((int)param_1,param_2); 30 | if (iVar1 != 0) { 31 | return iVar1; 32 | } 33 | param_2 = param_2 + 0x40; 34 | } 35 | if (param_3 != 0) { 36 | FUN_00007dca((undefined4 *)((int)param_1 + uVar3 + 0x28),(undefined4 *)param_2,param_3); 37 | } 38 | } 39 | return 0; 40 | } 41 | 42 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00007d84@00007d84.c: -------------------------------------------------------------------------------- 1 | 2 | char * FUN_00007d84(char *param_1,char param_2,int param_3) 3 | 4 | { 5 | bool bVar1; 6 | 7 | while( true ) { 8 | bVar1 = param_3 == 0; 9 | param_3 = param_3 + -1; 10 | if (bVar1) { 11 | return (char *)0x0; 12 | } 13 | if (param_2 == *param_1) break; 14 | param_1 = param_1 + 1; 15 | } 16 | return param_1; 17 | } 18 | 19 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00007d9e@00007d9e.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00007d9e(byte *param_1,byte *param_2,int param_3) 3 | 4 | { 5 | byte *pbVar1; 6 | undefined4 uVar2; 7 | byte *pbVar3; 8 | bool bVar4; 9 | 10 | do { 11 | pbVar3 = param_2; 12 | pbVar1 = param_1; 13 | bVar4 = param_3 == 0; 14 | param_3 = param_3 + -1; 15 | if (bVar4) { 16 | return 0; 17 | } 18 | param_1 = pbVar1 + 1; 19 | param_2 = pbVar3 + 1; 20 | } while (*pbVar1 == *pbVar3); 21 | if (*pbVar1 < *pbVar3) { 22 | uVar2 = 0xffffffff; 23 | } 24 | else { 25 | uVar2 = 1; 26 | } 27 | return uVar2; 28 | } 29 | 30 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00007dca@00007dca.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00007dca(undefined4 *param_1,undefined4 *param_2,uint param_3) 3 | 4 | { 5 | undefined4 *puVar1; 6 | undefined4 *puVar2; 7 | 8 | if ((((uint)param_2 | (uint)param_1) & 3) == 0) { 9 | puVar1 = param_2; 10 | puVar2 = param_1; 11 | if (3 < param_3) { 12 | do { 13 | param_2 = puVar1 + 1; 14 | param_1 = puVar2 + 1; 15 | *puVar2 = *puVar1; 16 | param_3 = param_3 - 4; 17 | puVar1 = param_2; 18 | puVar2 = param_1; 19 | } while (3 < param_3); 20 | } 21 | } 22 | else if (((((uint)param_2 | (uint)param_1) & 1) == 0) && 23 | (puVar1 = param_2, puVar2 = param_1, 1 < param_3)) { 24 | do { 25 | param_2 = (undefined4 *)((int)puVar1 + 2); 26 | param_1 = (undefined4 *)((int)puVar2 + 2); 27 | *(undefined2 *)puVar2 = *(undefined2 *)puVar1; 28 | param_3 = param_3 - 2; 29 | puVar1 = param_2; 30 | puVar2 = param_1; 31 | } while (1 < param_3); 32 | } 33 | for (; 0 < (int)param_3; param_3 = param_3 - 1) { 34 | *(undefined *)param_1 = *(undefined *)param_2; 35 | param_2 = (undefined4 *)((int)param_2 + 1); 36 | param_1 = (undefined4 *)((int)param_1 + 1); 37 | } 38 | return; 39 | } 40 | 41 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00007e18@00007e18.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00007e18(undefined4 *param_1,undefined param_2,uint param_3) 3 | 4 | { 5 | uint uVar1; 6 | undefined4 *puVar2; 7 | 8 | if (7 < param_3) { 9 | uVar1 = (uint)param_1 & 3; 10 | while (uVar1 != 0) { 11 | *(undefined *)param_1 = param_2; 12 | param_3 = param_3 - 1; 13 | uVar1 = (uint)((int)param_1 + 1) & 3; 14 | param_1 = (undefined4 *)((int)param_1 + 1); 15 | } 16 | uVar1 = param_3 >> 2; 17 | param_3 = param_3 & 3; 18 | puVar2 = param_1; 19 | do { 20 | param_1 = puVar2 + 1; 21 | *puVar2 = CONCAT22(CONCAT11(param_2,param_2),CONCAT11(param_2,param_2)); 22 | uVar1 = uVar1 - 1; 23 | puVar2 = param_1; 24 | } while (uVar1 != 0); 25 | } 26 | for (; param_3 != 0; param_3 = param_3 - 1) { 27 | *(undefined *)param_1 = param_2; 28 | param_1 = (undefined4 *)((int)param_1 + 1); 29 | } 30 | return; 31 | } 32 | 33 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00007e6a@00007e6a.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00007e6a(void) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | if (*(int *)(unaff_gp + 0x108) == 0) { 8 | FUN_00007eaa(); 9 | } 10 | if (*(int *)(unaff_gp + 0xf0) != 0) { 11 | *(undefined4 *)(unaff_gp + 0xf0) = 0; 12 | } 13 | FUN_00007e92(); 14 | *(undefined4 *)(unaff_gp + 0x108) = 1; 15 | return; 16 | } 17 | 18 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00007e92@00007e92.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_00007e92(void) 5 | 6 | { 7 | int unaff_gp; 8 | 9 | if (*(int *)(unaff_gp + 100) != 0) { 10 | _DAT_7c001f00 = _DAT_7c001f00 | 0xf; 11 | } 12 | return; 13 | } 14 | 15 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00007eaa@00007eaa.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00007eaa(void) 3 | 4 | { 5 | return; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00007eac@00007eac.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00007eac(void) 3 | 4 | { 5 | return; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00007eae@00007eae.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00007eae(int param_1) 3 | 4 | { 5 | int iVar1; 6 | undefined4 uVar2; 7 | code *pcVar3; 8 | int unaff_gp; 9 | 10 | if (param_1 == 0) { 11 | if (*(int *)(&DAT_00002f18 + unaff_gp) != 0) { 12 | FUN_0000bf1c(10000); 13 | } 14 | uRam7d5043a8 = 0; 15 | uRam7d504380 = 0x7f; 16 | iVar1 = FUN_0000b8a2(); 17 | pcVar3 = *(code **)(iVar1 + 0x24); 18 | uVar2 = 0x100; 19 | } 20 | else { 21 | FUN_0000e072(); 22 | uRam7d5043a8 = 0x1a0; 23 | uRam7d504380 = 0x10; 24 | iVar1 = FUN_0000b8a2(); 25 | pcVar3 = *(code **)(iVar1 + 0x24); 26 | uVar2 = 0x101; 27 | } 28 | (*pcVar3)(0x3f5,0x3f6,uVar2,pcVar3); 29 | return; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00008010@00008010.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00008010(undefined4 *param_1,undefined4 *param_2,undefined4 *param_3,undefined4 *param_4) 3 | 4 | { 5 | *param_1 = &DAT_7c038000; 6 | *param_3 = &DAT_7c034000; 7 | *param_2 = 0x8000; 8 | *param_4 = 0x2000; 9 | FUN_0000858c(0x7c030000); 10 | return; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000803c@0000803c.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_0000803c(void) 5 | 6 | { 7 | undefined4 extraout_r2; 8 | undefined4 extraout_r3; 9 | undefined4 extraout_r4; 10 | undefined4 extraout_r5; 11 | int iVar1; 12 | undefined8 uVar2; 13 | 14 | _DAT_7c001000 = 2; 15 | iVar1 = 0; 16 | FUN_0000bf1c(10); 17 | while ((_DAT_7c001000 & 0x8000) == 0) { 18 | uVar2 = FUN_0000bf1c(10); 19 | iVar1 = iVar1 + 1; 20 | if (0x14 < iVar1) { 21 | FUN_00009cdc((int)uVar2,(int)((ulonglong)uVar2 >> 0x20),extraout_r2,extraout_r3,extraout_r4, 22 | extraout_r5); 23 | } 24 | } 25 | return; 26 | } 27 | 28 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000806a@0000806a.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000806a(void) 3 | 4 | { 5 | FUN_00007eae(0); 6 | return 0; 7 | } 8 | 9 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00008076@00008076.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_00008076(undefined4 *param_1) 5 | 6 | { 7 | int unaff_gp; 8 | 9 | _DAT_7c001008 = param_1[1]; 10 | _DAT_7c001040 = param_1[0xd]; 11 | if (*(uint *)(&DAT_00002d14 + unaff_gp) < 4) { 12 | _DAT_7c001008 = (*(uint *)(&DAT_00002d14 + unaff_gp) & 7) << 0xc | _DAT_7c001008 & 0xffff8fff; 13 | } 14 | _DAT_7c001004 = *param_1; 15 | _DAT_7c00100c = param_1[2]; 16 | _DAT_7c001010 = param_1[3]; 17 | _DAT_7c001014 = param_1[4]; 18 | _DAT_7c001018 = param_1[5]; 19 | _DAT_7c00101c = param_1[6]; 20 | _DAT_7c001020 = param_1[7]; 21 | _DAT_7c001024 = param_1[8]; 22 | _DAT_7c001028 = param_1[9]; 23 | _DAT_7c001060 = param_1[0xf]; 24 | _DAT_7c001030 = param_1[0xb]; 25 | if ((*(int *)(unaff_gp + 100) != 0) && (*(int *)(unaff_gp + 0x88) == 0x80)) { 26 | _DAT_7c001040 = _DAT_7c001040 | 0x10000; 27 | } 28 | _DAT_7c001038 = param_1[0xc]; 29 | if (*(int *)(unaff_gp + 100) != 0) { 30 | _DAT_7c00102c = param_1[10]; 31 | _DAT_7c001048 = param_1[0xe]; 32 | } 33 | _DAT_7c001064 = param_1[0x10]; 34 | _DAT_7c001068 = param_1[0x11]; 35 | FUN_00007eac(); 36 | return; 37 | } 38 | 39 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00008112@00008112.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00008112(void) 3 | 4 | { 5 | int iVar1; 6 | 7 | iVar1 = 2; 8 | do { 9 | iVar1 = iVar1 + -1; 10 | } while (0 < iVar1); 11 | iVar1 = 3; 12 | do { 13 | iVar1 = iVar1 + -1; 14 | } while (0 < iVar1); 15 | return; 16 | } 17 | 18 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00008120@00008120.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00008120(undefined4 param_1) 3 | 4 | { 5 | undefined4 uVar1; 6 | 7 | switch(param_1) { 8 | case 0: 9 | uVar1 = 0x546; 10 | break; 11 | case 1: 12 | uVar1 = 0x870; 13 | break; 14 | case 2: 15 | uVar1 = 0x960; 16 | break; 17 | case 3: 18 | uVar1 = 0xa6b; 19 | break; 20 | case 4: 21 | uVar1 = 0xc80; 22 | break; 23 | case 5: 24 | uVar1 = 0xe95; 25 | break; 26 | case 6: 27 | uVar1 = 0x10ab; 28 | break; 29 | default: 30 | uVar1 = 0; 31 | } 32 | return uVar1; 33 | } 34 | 35 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000815c@0000815c.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_0000815c(int *param_1,uint param_2) 3 | 4 | { 5 | int iVar1; 6 | uint uVar2; 7 | 8 | iVar1 = 0; 9 | uVar2 = 0; 10 | if (param_2 >> 2 != 1) { 11 | do { 12 | iVar1 = iVar1 + *param_1; 13 | uVar2 = uVar2 + 1; 14 | param_1 = param_1 + 1; 15 | } while (uVar2 < (param_2 >> 2) - 1); 16 | } 17 | return iVar1; 18 | } 19 | 20 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000081e8@000081e8.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_000081e8(int param_1) 3 | 4 | { 5 | uint uVar1; 6 | uint uVar2; 7 | 8 | uVar2 = 0; 9 | uVar1 = *(uint *)(param_1 + 8); 10 | if (uVar1 != 0) { 11 | do { 12 | if ((*(uint *)(param_1 + 0xc) >> uVar2 & 1) != 0) { 13 | *(undefined4 *)(&DAT_00012000 + *(int *)(*(int *)(param_1 + 0x14) + uVar2 * 4)) = 1; 14 | uVar1 = *(uint *)(param_1 + 8); 15 | } 16 | uVar2 = uVar2 + 1; 17 | } while (uVar2 < uVar1); 18 | } 19 | return 0; 20 | } 21 | 22 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00008212@00008212.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00008212(int param_1) 3 | 4 | { 5 | uint uVar1; 6 | int iVar2; 7 | code *pcVar3; 8 | uint uVar4; 9 | uint uVar5; 10 | 11 | uVar4 = *(uint *)(param_1 + 8); 12 | uVar5 = 0; 13 | if (uVar4 != 0) { 14 | do { 15 | if ((*(uint *)(param_1 + 0xc) >> uVar5 & 1) != 0) { 16 | *(undefined4 *)(&DAT_00012000 + *(int *)(*(int *)(param_1 + 0x14) + uVar5 * 4)) = 1; 17 | uVar1 = (**(code **)(*(int *)(param_1 + 0x28) + 8))(); 18 | uVar4 = uVar1; 19 | do { 20 | pcVar3 = *(code **)(*(int *)(param_1 + 0x28) + 8); 21 | iVar2 = (*pcVar3)(uVar4,*(int *)(param_1 + 0x28),pcVar3); 22 | uVar4 = iVar2 - uVar1; 23 | } while (uVar4 < 1000); 24 | *(undefined4 *)(&DAT_00012000 + *(int *)(*(int *)(param_1 + 0x14) + uVar5 * 4)) = 5; 25 | uVar4 = *(uint *)(param_1 + 8); 26 | } 27 | uVar5 = uVar5 + 1; 28 | } while (uVar5 < uVar4); 29 | } 30 | return 0; 31 | } 32 | 33 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00008262@00008262.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00008262(int param_1) 3 | 4 | { 5 | uint uVar1; 6 | int iVar2; 7 | uint uVar3; 8 | 9 | uVar3 = 0; 10 | uVar1 = *(uint *)(param_1 + 8); 11 | if (uVar1 != 0) { 12 | do { 13 | if ((*(uint *)(param_1 + 0xc) >> uVar3 & 1) != 0) { 14 | iVar2 = *(int *)(param_1 + 0x14); 15 | *(undefined4 *)(&DAT_00012010 + *(int *)(iVar2 + uVar3 * 4)) = 0; 16 | *(undefined4 *)(&DAT_00012000 + *(int *)(iVar2 + uVar3 * 4)) = 0; 17 | uVar1 = *(uint *)(param_1 + 8); 18 | } 19 | uVar3 = uVar3 + 1; 20 | } while (uVar3 < uVar1); 21 | } 22 | return 0; 23 | } 24 | 25 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00008296@00008296.c: -------------------------------------------------------------------------------- 1 | 2 | int * FUN_00008296(int param_1,int param_2) 3 | 4 | { 5 | int *piVar1; 6 | 7 | piVar1 = (int *)(param_1 + param_2 * 4); 8 | return piVar1 + *piVar1 + 1; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00008426@00008426.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00008426(int param_1) 3 | 4 | { 5 | int iVar1; 6 | uint uVar2; 7 | bool bVar3; 8 | 9 | uVar2 = 0; 10 | if (*(uint *)(param_1 + 8) != 0) { 11 | do { 12 | if ((*(uint *)(param_1 + 0xc) >> uVar2 & 1) != 0) { 13 | iVar1 = 9999; 14 | do { 15 | if ((*(uint *)(&DAT_00013008 + *(int *)(*(int *)(param_1 + 0x14) + uVar2 * 4)) & 8) == 0) 16 | break; 17 | bVar3 = iVar1 != 0; 18 | iVar1 = iVar1 + -1; 19 | } while (bVar3); 20 | if (iVar1 == 0) { 21 | return 0x1c; 22 | } 23 | } 24 | uVar2 = uVar2 + 1; 25 | } while (uVar2 < *(uint *)(param_1 + 8)); 26 | } 27 | return 0; 28 | } 29 | 30 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000846c@0000846c.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000846c(int param_1,int param_2,int param_3) 3 | 4 | { 5 | int iVar1; 6 | int iVar2; 7 | int iVar3; 8 | undefined4 *puVar4; 9 | 10 | if ((*(uint *)(param_1 * 0x34 + param_3 + 0x24) & 1) != 0) { 11 | iVar1 = *(int *)(*(int *)(param_2 + 0x14) + param_1 * 4); 12 | iVar3 = 0; 13 | iVar2 = 0x98; 14 | puVar4 = *(undefined4 **)(*(int *)(param_2 + 0x1c) + param_1 * 4); 15 | do { 16 | *(undefined4 *)(&DAT_00014000 + iVar3 + *(int *)(param_3 + 0x20) + iVar1) = *puVar4; 17 | iVar3 = iVar3 + 4; 18 | iVar2 = iVar2 + -1; 19 | puVar4 = puVar4 + 1; 20 | } while (0 < iVar2); 21 | } 22 | return 0; 23 | } 24 | 25 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000858c@0000858c.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000858c(int param_1) 3 | 4 | { 5 | undefined4 *puVar1; 6 | int iVar2; 7 | 8 | *(undefined4 *)(param_1 + 0x2000) = 1; 9 | iVar2 = 0x2000; 10 | puVar1 = (undefined4 *)(param_1 + 0x8000); 11 | do { 12 | *puVar1 = 0; 13 | iVar2 = iVar2 + -1; 14 | puVar1 = puVar1 + 1; 15 | } while (0 < iVar2); 16 | iVar2 = 0x800; 17 | puVar1 = (undefined4 *)(param_1 + 0x4000); 18 | do { 19 | *puVar1 = 0; 20 | iVar2 = iVar2 + -1; 21 | puVar1 = puVar1 + 1; 22 | } while (0 < iVar2); 23 | return; 24 | } 25 | 26 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00008fde@00008fde.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00008fde(void) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | return *(undefined4 *)(unaff_gp + 0x108); 8 | } 9 | 10 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00008fe4@00008fe4.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_00008fe4(int param_1) 3 | 4 | { 5 | undefined4 *puVar1; 6 | int unaff_gp; 7 | undefined4 uStack_1c; 8 | undefined4 uStack_18; 9 | undefined4 uStack_14; 10 | undefined4 uStack_10; 11 | 12 | if (param_1 == 0) { 13 | puVar1 = *(undefined4 **)(unaff_gp + 0xf0); 14 | if (puVar1 == (undefined4 *)0x0) { 15 | puVar1 = FUN_0000b27e(); 16 | *(undefined4 **)(unaff_gp + 0xf0) = puVar1; 17 | } 18 | puVar1[2] = 0; 19 | *(undefined4 **)(unaff_gp + 0x57e0) = puVar1; 20 | *(undefined4 *)(unaff_gp + 0x57e4) = 0; 21 | } 22 | else { 23 | FUN_00008010(&uStack_10,&uStack_14,&uStack_18,&uStack_1c); 24 | FUN_000018fc((undefined4 *)(unaff_gp + 0x5820),unaff_gp + 0x5848,0xc); 25 | *(undefined4 **)(unaff_gp + 0x57e0) = (undefined4 *)(unaff_gp + 0x5820); 26 | FUN_000018fc((undefined4 *)(unaff_gp + 0x5834),uStack_10,uStack_14); 27 | *(undefined4 **)(unaff_gp + 0x57e4) = (undefined4 *)(unaff_gp + 0x5834); 28 | FUN_000018fc((undefined4 *)(unaff_gp + 0x580c),uStack_18,uStack_1c); 29 | *(undefined4 **)(unaff_gp + 0x57e8) = (undefined4 *)(unaff_gp + 0x580c); 30 | *(undefined4 *)(unaff_gp + 0x57ec) = 0; 31 | } 32 | return unaff_gp + 0x57e0; 33 | } 34 | 35 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000906a@0000906a.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000906a(undefined4 param_1,uint param_2,undefined4 param_3) 3 | 4 | { 5 | int iVar1; 6 | undefined4 uVar2; 7 | int unaff_gp; 8 | 9 | iVar1 = FUN_00007f14(param_1,param_2,unaff_gp + 0x5580,param_3); 10 | uVar2 = 0; 11 | if (iVar1 != 0) { 12 | uVar2 = 0xffffffff; 13 | } 14 | return uVar2; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00009084@00009084.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_00009084(int param_1) 3 | 4 | { 5 | undefined4 *puVar1; 6 | int unaff_gp; 7 | 8 | puVar1 = (undefined4 *)FUN_00008fe4(param_1); 9 | if (param_1 == 0) { 10 | *(undefined4 *)(unaff_gp + 0xe0) = *puVar1; 11 | } 12 | else { 13 | *(undefined4 *)(unaff_gp + 0xe0) = puVar1[1]; 14 | } 15 | *(undefined4 *)(unaff_gp + 0xe4) = 0; 16 | return unaff_gp + 0xe0; 17 | } 18 | 19 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000090a8@000090a8.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_000090a8(int param_1) 3 | 4 | { 5 | if (param_1 == 0xa6b) { 6 | return 3; 7 | } 8 | if (param_1 < 0xa6c) { 9 | if (param_1 == 0x870) { 10 | return 1; 11 | } 12 | if (param_1 < 0x871) { 13 | if (param_1 == 0x546) { 14 | return 0; 15 | } 16 | } 17 | else if (param_1 == 0x960) { 18 | return 2; 19 | } 20 | } 21 | else if (0xe94 < param_1) { 22 | if (param_1 == 0xe95) { 23 | return 5; 24 | } 25 | if (param_1 == 0x10ab) { 26 | return 6; 27 | } 28 | } 29 | return 4; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000090ee@000090ee.c: -------------------------------------------------------------------------------- 1 | 2 | uint FUN_000090ee(undefined *param_1,uint param_2) 3 | 4 | { 5 | uint uVar1; 6 | int iVar2; 7 | uint uVar3; 8 | uint uVar4; 9 | int iVar5; 10 | int iVar6; 11 | 12 | uVar4 = 0; 13 | iVar5 = 0x1c; 14 | iVar6 = 7; 15 | do { 16 | uVar1 = param_2 >> iVar5 & 0xf; 17 | if (uVar1 < 10) { 18 | iVar2 = uVar1 + 0x30; 19 | } 20 | else { 21 | iVar2 = uVar1 + 0x37; 22 | } 23 | iVar5 = iVar5 + -4; 24 | uVar1 = (*(code *)param_1)(iVar2); 25 | uVar4 = uVar4 | uVar1; 26 | iVar6 = iVar6 + -1; 27 | } while (-1 < iVar6); 28 | uVar1 = (*(code *)param_1)(0xd); 29 | uVar3 = (*(code *)param_1)(10); 30 | return uVar3 | uVar4 | uVar1; 31 | } 32 | 33 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00009128@00009128.c: -------------------------------------------------------------------------------- 1 | 2 | uint FUN_00009128(undefined *param_1,char *param_2) 3 | 4 | { 5 | uint uVar1; 6 | uint uVar2; 7 | 8 | uVar2 = 0; 9 | for (; *param_2 != '\0'; param_2 = param_2 + 1) { 10 | uVar1 = (*(code *)param_1)(); 11 | uVar2 = uVar2 | uVar1; 12 | } 13 | return uVar2; 14 | } 15 | 16 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00009142@00009142.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_00009142(int param_1,undefined4 *param_2) 3 | 4 | { 5 | int iVar1; 6 | int unaff_gp; 7 | 8 | iVar1 = FUN_0000806a(); 9 | if (iVar1 == 0) { 10 | if (param_1 == 2) { 11 | FUN_0000cc62(*(int *)(unaff_gp + 0x40)); 12 | FUN_0000803c(); 13 | } 14 | if (param_1 == 3) { 15 | FUN_00007e6a(); 16 | *param_2 = 1; 17 | } 18 | iVar1 = 0; 19 | } 20 | return iVar1; 21 | } 22 | 23 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00009170@00009170.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00009170(int param_1,uint param_2) 3 | 4 | { 5 | if (param_2 != 0) { 6 | *(uint *)(param_1 + (param_2 >> 5) * 4) = 7 | *(uint *)(param_1 + (param_2 >> 5) * 4) | 1 << (param_2 & 0x1f); 8 | } 9 | return 0; 10 | } 11 | 12 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00009188@00009188.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00009188(uint *param_1,int param_2) 3 | 4 | { 5 | uint *puVar1; 6 | undefined8 uVar2; 7 | undefined8 uVar3; 8 | 9 | if ((param_2 != 0) && (puVar1 = param_1 + param_2 * 2 + -2, param_1 <= puVar1)) { 10 | do { 11 | uVar2 = thunk_FUN_000097bc(*param_1,param_1[1]); 12 | uVar3 = thunk_FUN_000097bc(*puVar1,puVar1[1]); 13 | *(undefined8 *)param_1 = uVar3; 14 | param_1 = param_1 + 2; 15 | *(undefined8 *)puVar1 = uVar2; 16 | puVar1 = puVar1 + -2; 17 | } while (param_1 <= puVar1); 18 | } 19 | return; 20 | } 21 | 22 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000091bc@000091bc.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_000091bc(int *param_1,int param_2) 3 | 4 | { 5 | uint uVar1; 6 | uint uVar2; 7 | int iVar3; 8 | int iVar4; 9 | uint uVar5; 10 | uint uVar6; 11 | undefined8 uVar7; 12 | undefined8 uVar8; 13 | 14 | uVar6 = 0x40; 15 | uVar1 = **(uint **)(param_2 + 8); 16 | uVar5 = (*(uint **)(param_2 + 8))[1]; 17 | uVar2 = (uVar1 + 2 & 4) * 2; 18 | iVar4 = uVar2 + uVar1; 19 | uVar8 = CONCAT44(uVar5,iVar4); 20 | if (CARRY4(uVar2,uVar1)) { 21 | uVar8 = CONCAT44(uVar5 + 1,iVar4); 22 | } 23 | do { 24 | iVar3 = (int)((ulonglong)uVar8 >> 0x20); 25 | uVar7 = FUN_0000039c(uVar1,uVar5,(uint)uVar8,iVar3); 26 | iVar4 = -(int)((ulonglong)uVar7 >> 0x20); 27 | if (2 < (uint)uVar7) { 28 | iVar4 = iVar4 + -1; 29 | } 30 | uVar8 = FUN_0000039c(2 - (uint)uVar7,iVar4,(uint)uVar8,iVar3); 31 | uVar6 = uVar6 >> 1; 32 | } while (7 < uVar6); 33 | *param_1 = ~(uint)uVar8 + 1; 34 | uVar1 = ~(uint)((ulonglong)uVar8 >> 0x20); 35 | if (~(uint)uVar8 == 0xffffffff) { 36 | uVar1 = uVar1 + 1; 37 | } 38 | param_1[1] = uVar1; 39 | return; 40 | } 41 | 42 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00009336@00009336.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00009336(int param_1,int param_2,uint param_3,int param_4,int param_5) 3 | 4 | { 5 | undefined4 local_24; 6 | undefined4 local_20; 7 | undefined4 *local_1c; 8 | undefined4 local_18; 9 | undefined4 local_14; 10 | 11 | local_24 = 1; 12 | local_20 = 1; 13 | local_18 = 1; 14 | local_14 = 0; 15 | local_1c = &local_18; 16 | FUN_00009222(param_1,(int)&local_24,param_2,param_3,param_4,param_5); 17 | return; 18 | } 19 | 20 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000097bc@000097bc.c: -------------------------------------------------------------------------------- 1 | 2 | undefined8 FUN_000097bc(uint param_1,uint param_2) 3 | 4 | { 5 | uint uVar1; 6 | uint uVar2; 7 | uint uVar3; 8 | uint uVar4; 9 | longlong lVar5; 10 | 11 | uVar4 = 0; 12 | uVar3 = 0; 13 | uVar2 = 0; 14 | do { 15 | lVar5 = FUN_000003c8(param_1 & 0xff,0,(7 - uVar2) * 8); 16 | uVar1 = param_2 << 0x18; 17 | uVar4 = uVar4 | (uint)lVar5; 18 | uVar3 = uVar3 | (uint)((ulonglong)lVar5 >> 0x20); 19 | uVar2 = uVar2 + 1 & 0xff; 20 | param_2 = param_2 >> 8; 21 | param_1 = param_1 >> 8 | uVar1; 22 | } while (uVar2 < 8); 23 | return CONCAT44(uVar3,uVar4); 24 | } 25 | 26 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000097fe@000097fe.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_000097fe(undefined4 *param_1,undefined *param_2) 3 | 4 | { 5 | undefined4 uVar1; 6 | 7 | uVar1 = param_1[1]; 8 | *param_2 = (char)((uint)uVar1 >> 0x18); 9 | param_2[1] = (char)((uint)uVar1 >> 0x10); 10 | param_2[2] = (char)((uint)uVar1 >> 8); 11 | param_2[3] = (char)uVar1; 12 | uVar1 = *param_1; 13 | param_2[4] = (char)((uint)uVar1 >> 0x18); 14 | param_2[5] = (char)((uint)uVar1 >> 0x10); 15 | return; 16 | } 17 | 18 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000098ec@000098ec.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_000098ec(uint param_1) 3 | 4 | { 5 | uint uVar1; 6 | int iVar2; 7 | 8 | uVar1 = param_1 & 0xf; 9 | if (uVar1 < 10) { 10 | iVar2 = uVar1 + 0x30; 11 | } 12 | else { 13 | iVar2 = uVar1 + 0x57; 14 | } 15 | return iVar2; 16 | } 17 | 18 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000098fe@000098fe.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | undefined4 FUN_000098fe(uint param_1) 5 | 6 | { 7 | int iVar1; 8 | undefined4 uVar2; 9 | 10 | _DAT_7d00f008 = param_1; 11 | FUN_0000bf1c(10); 12 | uVar2 = 0xffffffff; 13 | if (param_1 == _DAT_7d00f008) { 14 | iVar1 = 999; 15 | _DAT_7d00f008 = _DAT_7d00f008 | 1; 16 | do { 17 | FUN_0000bf1c(10); 18 | if ((_DAT_7d00f00c & 2) != 0) { 19 | if ((_DAT_7d00f00c & 0xf0000000) == 0) { 20 | uVar2 = 0; 21 | } 22 | else { 23 | uVar2 = 0xfffffffd; 24 | } 25 | break; 26 | } 27 | iVar1 = iVar1 + -1; 28 | } while (-1 < iVar1); 29 | _DAT_7d00f008 = 0; 30 | FUN_0000bf1c(10); 31 | } 32 | return uVar2; 33 | } 34 | 35 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000099d8@000099d8.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_000099d8(uint param_1,undefined4 param_2) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | if (param_1 < 0xc0) { 8 | *(undefined4 *)(unaff_gp + 0x5854 + param_1 * 4) = param_2; 9 | } 10 | return; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000099ea@000099ea.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_000099ea(int param_1,undefined *param_2,undefined4 param_3,uint param_4,char *param_5) 3 | 4 | { 5 | uint uVar1; 6 | uint uVar2; 7 | uint unaff_r7; 8 | bool bVar3; 9 | 10 | uVar1 = 0; 11 | if (param_5 != (char *)0x0) { 12 | uVar1 = FUN_0000df42(param_5); 13 | } 14 | bVar3 = param_4 == uVar1; 15 | uVar2 = param_4; 16 | if (uVar1 < param_4) { 17 | unaff_r7 = 0; 18 | uVar2 = param_4 - uVar1; 19 | } 20 | if (uVar1 < param_4) { 21 | bVar3 = uVar2 == 0; 22 | } 23 | if ((uVar1 < param_4 || uVar1 <= param_4) && !bVar3) { 24 | do { 25 | if (*(uint *)(param_1 + 8) <= *(uint *)(param_1 + 4)) break; 26 | (*(code *)param_2)(param_1,param_3); 27 | unaff_r7 = unaff_r7 + 1; 28 | } while (unaff_r7 < uVar2); 29 | } 30 | while (((param_5 != (char *)0x0 && (*param_5 != '\0')) && 31 | (*(uint *)(param_1 + 4) < *(uint *)(param_1 + 8)))) { 32 | param_5 = param_5 + 1; 33 | (*(code *)param_2)(param_1); 34 | } 35 | return; 36 | } 37 | 38 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00009ca4@00009ca4.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00009ca4(undefined4 *param_1,int *param_2) 3 | 4 | { 5 | int iVar1; 6 | uint uVar2; 7 | byte *pbVar3; 8 | 9 | pbVar3 = (byte *)*param_1; 10 | iVar1 = 0; 11 | uVar2 = (uint)*pbVar3; 12 | if ((0x2f < uVar2) && (uVar2 < 0x3a)) { 13 | do { 14 | pbVar3 = pbVar3 + 1; 15 | iVar1 = iVar1 * 10 + uVar2; 16 | uVar2 = (uint)*pbVar3; 17 | iVar1 = iVar1 + -0x30; 18 | if (uVar2 < 0x30) break; 19 | } while (uVar2 < 0x3a); 20 | *param_1 = pbVar3; 21 | if ((iVar1 < 0x30) || (iVar1 == 0x79)) { 22 | *param_2 = iVar1; 23 | return 1; 24 | } 25 | } 26 | return 0; 27 | } 28 | 29 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00009cdc@00009cdc.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_00009cdc(undefined4 param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4, 3 | undefined4 param_5,undefined4 param_6) 4 | 5 | { 6 | code *pcVar1; 7 | int unaff_gp; 8 | uint unaff_lr; 9 | 10 | _sprintf_to_stdout((byte *)s_Unexpected_error___0x_08x_00009d04,unaff_lr,param_3,param_4,param_5, 11 | param_6); 12 | if (*(int *)(unaff_gp + 0x3d8) == 0) { 13 | pcVar1 = (code *)swi(0xe); 14 | (*pcVar1)(); 15 | } 16 | else { 17 | FUN_0000a3e8(0x45); 18 | } 19 | return; 20 | } 21 | 22 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00009e48@00009e48.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_00009e48(undefined4 *param_1) 3 | 4 | { 5 | *param_1 = 0x40000; 6 | return 0xc0d20000; 7 | } 8 | 9 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00009e56@00009e56.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_00009e56(void) 3 | 4 | { 5 | code *pcVar1; 6 | int iVar2; 7 | int unaff_gp; 8 | 9 | pcVar1 = *(code **)(*(int *)(unaff_gp + 0x124) + 0xcc); 10 | iVar2 = (*pcVar1)(pcVar1); 11 | if (iVar2 != 0) { 12 | FUN_0000a3e8(8); 13 | } 14 | return iVar2; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00009e74@00009e74.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_00009e74(void) 5 | 6 | { 7 | bool bVar1; 8 | undefined4 uVar2; 9 | undefined3 extraout_var; 10 | undefined4 extraout_r3; 11 | undefined4 extraout_r4; 12 | undefined4 extraout_r5; 13 | int unaff_gp; 14 | 15 | FUN_0000e13e(); 16 | _write_to_stdout((byte *)s_RPi__s__s__s__s__s_00009f10,0x9f04,unaff_gp + 0x295,DAT_0000fad0, 17 | DAT_0000fac8,DAT_0000facc); 18 | uVar2 = FUN_00000532(); 19 | _write_to_stdout((byte *)s_BOOTMODE__0x_02x_partition__d_bu_00009f88,*(uint *)(unaff_gp + 0x3d8), 20 | uVar2,*(undefined4 *)(unaff_gp + 0x28),*(undefined4 *)(unaff_gp + 0xa4), 21 | *(undefined4 *)(unaff_gp + 0x94)); 22 | _write_to_stdout((byte *)s_AON_RESET___08x_PM_RSTS__08x_00009f24,_DAT_7d51506c,_DAT_7d200020, 23 | extraout_r3,0x7d200000,0x7d515040); 24 | bVar1 = FUN_0000af6a(); 25 | _write_to_stdout((byte *)s_POWER_OFF_ON_HALT___d_WAIT_FOR_P_00009f44, 26 | *(uint *)(&DAT_00002d10 + unaff_gp),*(undefined4 *)(&DAT_0000304c + unaff_gp), 27 | CONCAT31(extraout_var,bVar1),extraout_r4,extraout_r5); 28 | return; 29 | } 30 | 31 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000a2a2@0000a2a2.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000a2a2(void) 3 | 4 | { 5 | return 200000000; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000a3e8@0000a3e8.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_0000a3e8(uint param_1) 5 | 6 | { 7 | int iVar1; 8 | char *pcVar2; 9 | undefined4 extraout_r2; 10 | undefined4 extraout_r3; 11 | undefined4 extraout_r3_00; 12 | undefined4 extraout_r4; 13 | undefined4 extraout_r4_00; 14 | undefined4 extraout_r5; 15 | undefined4 extraout_r5_00; 16 | int unaff_gp; 17 | undefined8 uVar3; 18 | 19 | iVar1 = FUN_000009b4(); 20 | if ((iVar1 == 0) && (*(int *)(unaff_gp + 0x84) == 0)) { 21 | *(undefined4 *)(unaff_gp + 0x84) = 1; 22 | uVar3 = FUN_0000a48c(1,0); 23 | FUN_0000e460((int)uVar3,(uint)((ulonglong)uVar3 >> 0x20),extraout_r2,extraout_r3,extraout_r4, 24 | extraout_r5); 25 | pcVar2 = FUN_00003d9c(param_1); 26 | _sprintf_to_stdout((byte *)s_BOOT_ERROR__code__x_____s__0000a44c,param_1,pcVar2,extraout_r3_00, 27 | extraout_r4_00,extraout_r5_00); 28 | FUN_0000b2a4(); 29 | iVar1 = _DAT_7c003004; 30 | do { 31 | do { 32 | FUN_0000a332(param_1,0); 33 | } while ((uint)(_DAT_7c003004 - iVar1) < 0x11e1a301); 34 | FUN_0000367e(); 35 | } while( true ); 36 | } 37 | return; 38 | } 39 | 40 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000a468@0000a468.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000a468(undefined4 *param_1) 3 | 4 | { 5 | *param_1 = 0xc00000; 6 | return 0xc1770000; 7 | } 8 | 9 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000a476@0000a476.c: -------------------------------------------------------------------------------- 1 | 2 | undefined FUN_0000a476(void) 3 | 4 | { 5 | undefined uVar1; 6 | int iVar2; 7 | 8 | iVar2 = FUN_0000b8a2(); 9 | uVar1 = (**(code **)(iVar2 + 0x84))(0x22,*(code **)(iVar2 + 0x84)); 10 | return uVar1; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000a48c@0000a48c.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000a48c(undefined4 param_1,uint param_2) 3 | 4 | { 5 | code *pcVar1; 6 | bool bVar2; 7 | undefined3 extraout_var; 8 | undefined4 uVar3; 9 | undefined4 extraout_r2; 10 | undefined4 extraout_r3; 11 | undefined4 extraout_r4; 12 | undefined4 extraout_r5; 13 | int unaff_gp; 14 | 15 | bVar2 = FUN_00000666(); 16 | if (CONCAT31(extraout_var,bVar2) != 0) { 17 | _write_to_stdout((byte *)s_Halt__power_off___u_0000a4c0,param_2,extraout_r2,extraout_r3, 18 | extraout_r4,extraout_r5); 19 | uVar3 = FUN_0000e072(); 20 | if (param_2 == 0) { 21 | FUN_0000053c(1); 22 | } 23 | else { 24 | pcVar1 = *(code **)(*(int *)(unaff_gp + 0x124) + 0x78); 25 | (*pcVar1)(uVar3,pcVar1); 26 | } 27 | } 28 | return; 29 | } 30 | 31 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000a4d4@0000a4d4.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000a4d4(void) 3 | 4 | { 5 | return 1; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000a4d8@0000a4d8.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000a4d8(void) 3 | 4 | { 5 | return 1; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000a4dc@0000a4dc.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000a4dc(void) 3 | 4 | { 5 | return 0; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000a4e0@0000a4e0.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000a4e0(void) 3 | 4 | { 5 | return 0; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000a780@0000a780.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000a780(void) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | if (*(int *)(unaff_gp + 0x3d8) == 7) { 8 | *(undefined4 *)(unaff_gp + 0x2cfc) = 1; 9 | } 10 | if (*(int *)(unaff_gp + 0xcc) == 0) { 11 | if (*(int *)(unaff_gp + 0x2cfc) != 0) { 12 | FUN_0000e09e(*(int *)(unaff_gp + 0x124),&DAT_0001c200); 13 | } 14 | *(undefined4 *)(unaff_gp + 0xcc) = 1; 15 | } 16 | return; 17 | } 18 | 19 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000a7bc@0000a7bc.c: -------------------------------------------------------------------------------- 1 | 2 | bool FUN_0000a7bc(void) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | return *(int *)(unaff_gp + 0x98) == 0x14; 8 | } 9 | 10 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000a7ca@0000a7ca.c: -------------------------------------------------------------------------------- 1 | 2 | bool FUN_0000a7ca(void) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | return *(int *)(unaff_gp + 0x98) == 0x15; 8 | } 9 | 10 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000a7d8@0000a7d8.c: -------------------------------------------------------------------------------- 1 | 2 | bool FUN_0000a7d8(void) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | return *(int *)(unaff_gp + 0x98) == 0x18 || *(int *)(unaff_gp + 0x98) == 0x1a; 8 | } 9 | 10 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000a7ea@0000a7ea.c: -------------------------------------------------------------------------------- 1 | 2 | bool FUN_0000a7ea(void) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | return *(int *)(unaff_gp + 0x98) == 0x13; 8 | } 9 | 10 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000a7f8@0000a7f8.c: -------------------------------------------------------------------------------- 1 | 2 | bool FUN_0000a7f8(void) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | return *(int *)(unaff_gp + 0x98) == 0x11; 8 | } 9 | 10 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000a806@0000a806.c: -------------------------------------------------------------------------------- 1 | 2 | bool FUN_0000a806(void) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | return *(int *)(unaff_gp + 0x98) == 0x17; 8 | } 9 | 10 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000a814@0000a814.c: -------------------------------------------------------------------------------- 1 | 2 | bool FUN_0000a814(void) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | return *(int *)(unaff_gp + 0x98) == 0x19; 8 | } 9 | 10 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000a964@0000a964.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000a964(byte *param_1) 3 | 4 | { 5 | int iVar1; 6 | int iVar2; 7 | undefined4 uVar3; 8 | int unaff_gp; 9 | 10 | iVar2 = *(int *)(unaff_gp + 0x4f4); 11 | for (; *param_1 == 0x20 || *param_1 == 9; param_1 = param_1 + 1) { 12 | } 13 | if (((((iVar2 < 0x5dc) && (iVar1 = FUN_0000b6f0(param_1,&LAB_0000a9f4,3), iVar1 == 0)) || 14 | ((0x5db < iVar2 && 15 | ((iVar2 < 3000 && (iVar1 = FUN_0000b6f0(param_1,&LAB_0000a9f8,4), iVar1 == 0)))))) || 16 | ((2999 < iVar2 && 17 | ((iVar2 < 5000 && (iVar1 = FUN_0000b6f0(param_1,&DAT_0000a9ec,2), iVar1 == 0)))))) || 18 | ((4999 < iVar2 && (iVar2 = FUN_0000b6f0(param_1,&LAB_0000a9f0,2), iVar2 == 0)))) { 19 | uVar3 = 1; 20 | } 21 | else { 22 | uVar3 = 0; 23 | } 24 | return uVar3; 25 | } 26 | 27 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000a9fe@0000a9fe.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_0000a9fe(undefined4 *param_1) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | *param_1 = 0x1c00; 8 | return unaff_gp + 0x3250; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000aa0c@0000aa0c.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000aa0c(void) 3 | 4 | { 5 | int *intPointer; 6 | uint index; 7 | int counter; 8 | uint currentValue; 9 | bool isExpected; 10 | 11 | isExpected = false; 12 | counter = 0; 13 | intPointer = (int *)&DAT_c1000000; 14 | do { 15 | *intPointer = counter; 16 | counter = counter + 1; 17 | intPointer = intPointer + 1; 18 | } while (counter < 0x100000); 19 | do { 20 | if (isExpected) { 21 | return; 22 | } 23 | index = 0; 24 | do { 25 | currentValue = *(uint *)(&DAT_c1000000 + index * 4); 26 | if (index != currentValue) { 27 | _sprintf_to_stdout((byte *)s_Loop__d_address__p_expected__08x_0000aa58,1, 28 | &DAT_c1000000 + index * 4,index,currentValue,counter); 29 | FUN_0000a3e8(8); 30 | return; 31 | } 32 | index = index + 1; 33 | } while (index < 0x100000); 34 | isExpected = true; 35 | } while( true ); 36 | } 37 | 38 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000aa84@0000aa84.c: -------------------------------------------------------------------------------- 1 | 2 | uint FUN_0000aa84(byte *param_1) 3 | 4 | { 5 | return (uint)param_1[3] | 6 | (uint)param_1[2] << 8 | (uint)param_1[1] << 0x10 | (uint)*param_1 << 0x18; 7 | } 8 | 9 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000aaa0@0000aaa0.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000aaa0(void) 3 | 4 | { 5 | return 0x42580000; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000aaa8@0000aaa8.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000aaa8(uint param_1,char *param_2,int param_3) 3 | 4 | { 5 | char cVar1; 6 | 7 | if ((0x40 < (int)param_1) && ((int)param_1 < 0x5b)) { 8 | param_1 = param_1 + 0x20 & 0xff; 9 | } 10 | if (((int)param_1 < 0x30) || (0x39 < (int)param_1)) { 11 | if ((param_3 == 0) || (((int)param_1 < 0x61 || (0x66 < (int)param_1)))) { 12 | return 0xffffffff; 13 | } 14 | cVar1 = (char)param_1 + -0x57; 15 | } 16 | else { 17 | cVar1 = (char)param_1 + -0x30; 18 | } 19 | *param_2 = cVar1; 20 | return 0; 21 | } 22 | 23 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000aae4@0000aae4.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_0000aae4(byte *param_1,undefined4 *param_2,int param_3) 3 | 4 | { 5 | uint uVar1; 6 | int iVar2; 7 | int iVar3; 8 | int extraout_r3; 9 | int extraout_r5; 10 | byte local_11; 11 | 12 | uVar1 = (uint)*param_1; 13 | iVar3 = 0; 14 | if (uVar1 != 0) { 15 | do { 16 | if ((0x40 < uVar1) && (uVar1 < 0x5b)) { 17 | uVar1 = uVar1 + 0x20 & 0xff; 18 | } 19 | if ((0x40 < uVar1) && (uVar1 < 0x5b)) { 20 | uVar1 = uVar1 + 0x20 & 0xff; 21 | } 22 | iVar2 = FUN_0000aaa8(uVar1,(char *)&local_11,param_3); 23 | iVar3 = extraout_r3; 24 | if (iVar2 < 0) break; 25 | param_1 = param_1 + 1; 26 | uVar1 = (uint)*param_1; 27 | iVar3 = extraout_r3 << 4; 28 | if (extraout_r5 == 0) { 29 | iVar3 = extraout_r3 * 10; 30 | } 31 | iVar3 = (uint)local_11 + iVar3; 32 | param_3 = extraout_r5; 33 | } while (uVar1 != 0); 34 | } 35 | if (param_2 != (undefined4 *)0x0) { 36 | *param_2 = param_1; 37 | } 38 | return iVar3; 39 | } 40 | 41 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000abda@0000abda.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000abda(byte *param_1,undefined *param_2) 3 | 4 | { 5 | uint uVar1; 6 | int iVar2; 7 | undefined4 uVar3; 8 | int iVar4; 9 | byte *local_18; 10 | 11 | if ((param_1 == (byte *)0x0) || (uVar1 = FUN_0000df42((char *)param_1), uVar1 < 0x11)) { 12 | LAB_0000ac24: 13 | uVar3 = 0xffffffff; 14 | } 15 | else { 16 | iVar4 = 0; 17 | do { 18 | local_18 = param_1; 19 | iVar2 = FUN_0000aae4(param_1,&local_18,1); 20 | *param_2 = (char)iVar2; 21 | if (((iVar4 < 5) && (*local_18 != 0x3a)) || ((int)local_18 - (int)param_1 != 2)) 22 | goto LAB_0000ac24; 23 | param_1 = local_18 + 1; 24 | param_2 = param_2 + 1; 25 | iVar4 = iVar4 + 1; 26 | } while (iVar4 < 6); 27 | uVar3 = 0; 28 | } 29 | return uVar3; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000adac@0000adac.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000adac(uint *param_1,uint *param_2) 3 | 4 | { 5 | int iVar1; 6 | int extraout_r3; 7 | int extraout_r4; 8 | undefined4 extraout_r5; 9 | byte *pbVar2; 10 | byte *pbVar3; 11 | int aiStack_d8 [6]; 12 | byte *local_c0; 13 | undefined auStack_b8 [128]; 14 | int *local_38; 15 | undefined4 local_34; 16 | int aiStack_30 [2]; 17 | undefined4 local_28; 18 | byte *local_24; 19 | 20 | local_34 = DAT_0000ed54; 21 | local_38 = aiStack_30; 22 | iVar1 = FUN_0000d534(param_2,aiStack_d8); 23 | pbVar3 = (byte *)0x0; 24 | if ((iVar1 == 0) && (FUN_000018fc(aiStack_30,auStack_b8,0x80), local_c0 != (byte *)0x0)) { 25 | do { 26 | local_28 = 0; 27 | pbVar2 = local_24; 28 | if (local_c0 < local_24 + (int)pbVar3) { 29 | pbVar2 = local_c0 + -(int)pbVar3; 30 | } 31 | if ((int)pbVar2 < 1) { 32 | return; 33 | } 34 | FUN_0000d86c(aiStack_d8,(int *)&local_38,(int)pbVar3,pbVar2,(undefined4 *)0x0,(byte *)0x0,0); 35 | FUN_00002c76(param_1,aiStack_30,0,extraout_r3,extraout_r4,extraout_r5); 36 | pbVar3 = pbVar3 + (int)pbVar2; 37 | } while (pbVar3 < local_c0); 38 | } 39 | return; 40 | } 41 | 42 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000af30@0000af30.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | undefined4 FUN_0000af30(undefined *param_1,undefined4 param_2,uint param_3,int param_4) 5 | 6 | { 7 | int iVar1; 8 | int iVar2; 9 | 10 | iVar2 = _DAT_7c003004 + -1; 11 | while( true ) { 12 | iVar1 = (*(code *)param_1)(param_2); 13 | if (iVar1 == 0) { 14 | return 0; 15 | } 16 | if (param_3 <= (uint)(_DAT_7c003004 - iVar2)) break; 17 | if (param_4 != 0) { 18 | FUN_0000bf1c(param_4); 19 | } 20 | } 21 | return 0xffffffff; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000af6a@0000af6a.c: -------------------------------------------------------------------------------- 1 | 2 | bool FUN_0000af6a(void) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | return (*(uint *)(unaff_gp + 0x52c) & 0x20) == 0; 8 | } 9 | 10 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000af7a@0000af7a.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000af7a(byte *param_1,uint param_2,undefined4 param_3,undefined4 param_4, 3 | undefined4 param_5,undefined4 param_6) 4 | 5 | { 6 | uint local_14; 7 | undefined4 local_10; 8 | undefined4 local_c; 9 | undefined4 local_8; 10 | undefined4 local_4; 11 | 12 | local_14 = param_2; 13 | local_10 = param_3; 14 | local_c = param_4; 15 | local_8 = param_5; 16 | local_4 = param_6; 17 | FUN_0000ba8c(param_1,&local_14); 18 | return; 19 | } 20 | 21 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000af96@0000af96.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000af96(void) 3 | 4 | { 5 | code *UNRECOVERED_JUMPTABLE; 6 | int unaff_gp; 7 | 8 | UNRECOVERED_JUMPTABLE = *(code **)(*(int *)(unaff_gp + 0x124) + 0x68); 9 | /* WARNING: Could not recover jumptable at 0x0000af9e. Too many branches */ 10 | /* WARNING: Treating indirect jump as call */ 11 | (*UNRECOVERED_JUMPTABLE)(UNRECOVERED_JUMPTABLE); 12 | return; 13 | } 14 | 15 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b092@0000b092.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000b092(undefined4 *param_1) 3 | 4 | { 5 | int iVar1; 6 | int iVar2; 7 | undefined4 uStack_18; 8 | 9 | iVar2 = 0x25; 10 | iVar1 = 8; 11 | do { 12 | FUN_0000ca68(iVar2,param_1,&uStack_18); 13 | iVar2 = iVar2 + 1; 14 | iVar1 = iVar1 + -1; 15 | param_1 = param_1 + 1; 16 | } while (0 < iVar1); 17 | return; 18 | } 19 | 20 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b15c@0000b15c.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_0000b15c(undefined4 *param_1) 3 | 4 | { 5 | undefined4 *puVar1; 6 | int iVar2; 7 | int *piVar3; 8 | int unaff_gp; 9 | 10 | piVar3 = (int *)(unaff_gp + 0xbc); 11 | iVar2 = *piVar3; 12 | if (iVar2 == 0) { 13 | puVar1 = (undefined4 *)FUN_00004614(); 14 | *piVar3 = (int)puVar1; 15 | (*(code *)*puVar1)(); 16 | (**(code **)(*piVar3 + 0xc))(0,unaff_gp + 0xc4); 17 | iVar2 = *piVar3; 18 | } 19 | *param_1 = *(undefined4 *)(unaff_gp + 0xc4); 20 | return iVar2; 21 | } 22 | 23 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b27e@0000b27e.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 * FUN_0000b27e(void) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | FUN_000018fc((undefined4 *)(unaff_gp + 0x5b68),unaff_gp + 0x5ff0,0xa010); 8 | return (undefined4 *)(unaff_gp + 0x5b68); 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b2a4@0000b2a4.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000b2a4(void) 3 | 4 | { 5 | int iVar1; 6 | undefined4 uVar2; 7 | int unaff_gp; 8 | 9 | uVar2 = 0; 10 | if ((*(int *)(unaff_gp + 0x4c) != 0) || (iVar1 = FUN_00008fde(), iVar1 != 0)) { 11 | uVar2 = 1; 12 | } 13 | return uVar2; 14 | } 15 | 16 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b2be@0000b2be.c: -------------------------------------------------------------------------------- 1 | 2 | uint FUN_0000b2be(int param_1,int param_2,int param_3,undefined4 param_4,undefined4 param_5, 3 | undefined4 param_6) 4 | 5 | { 6 | uint uVar1; 7 | 8 | uVar1 = 0; 9 | if (param_1 != 0) { 10 | uVar1 = 0x10; 11 | } 12 | if (param_2 != 0) { 13 | uVar1 = uVar1 | 8; 14 | } 15 | if (param_3 == 0x20) { 16 | return uVar1 | 5; 17 | } 18 | if (param_3 < 0x21) { 19 | if (param_3 == 8) { 20 | return uVar1 | 7; 21 | } 22 | if (param_3 == 0x10) { 23 | return uVar1 | 6; 24 | } 25 | } 26 | else { 27 | if (param_3 == 0x40) { 28 | return uVar1 | 4; 29 | } 30 | if (param_3 == 0x80) { 31 | return uVar1 | 3; 32 | } 33 | } 34 | FUN_00009cdc(param_1,param_2,param_3,uVar1,param_5,param_6); 35 | return 0; 36 | } 37 | 38 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b310@0000b310.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000b310(uint param_1) 3 | 4 | { 5 | undefined4 uVar1; 6 | 7 | switch(param_1 & 7) { 8 | default: 9 | uVar1 = 0; 10 | break; 11 | case 3: 12 | uVar1 = 0x80; 13 | break; 14 | case 4: 15 | uVar1 = 0x40; 16 | break; 17 | case 5: 18 | uVar1 = 0x20; 19 | break; 20 | case 6: 21 | uVar1 = 0x10; 22 | break; 23 | case 7: 24 | uVar1 = 8; 25 | } 26 | return uVar1; 27 | } 28 | 29 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b33e@0000b33e.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000b33e(int param_1) 3 | 4 | { 5 | code *UNRECOVERED_JUMPTABLE; 6 | int unaff_gp; 7 | 8 | UNRECOVERED_JUMPTABLE = *(code **)(*(int *)(unaff_gp + 0x124) + 0x9c); 9 | *(uint *)(unaff_gp + 0xdc) = (uint)(param_1 != 0); 10 | /* WARNING: Could not recover jumptable at 0x0000b352. Too many branches */ 11 | /* WARNING: Treating indirect jump as call */ 12 | (*UNRECOVERED_JUMPTABLE)((uint)(param_1 != 0),UNRECOVERED_JUMPTABLE); 13 | return; 14 | } 15 | 16 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b354@0000b354.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000b354(int param_1) 3 | 4 | { 5 | int iVar1; 6 | undefined4 local_c; 7 | 8 | iVar1 = FUN_0000c420(); 9 | if (iVar1 != 0) { 10 | iVar1 = FUN_0000b15c(&local_c); 11 | if (param_1 == 0) { 12 | (**(code **)(iVar1 + 0x2c))(local_c,0x2c,1,*(code **)(iVar1 + 0x2c)); 13 | } 14 | else { 15 | (**(code **)(iVar1 + 0x30))(local_c,0x2c,1); 16 | } 17 | } 18 | return; 19 | } 20 | 21 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b388@0000b388.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000b388(int param_1,uint param_2,byte *param_3,uint param_4,undefined4 param_5, 3 | undefined4 param_6) 4 | 5 | { 6 | uint local_c; 7 | undefined4 local_8; 8 | undefined4 local_4; 9 | 10 | local_c = param_4; 11 | local_8 = param_5; 12 | local_4 = param_6; 13 | FUN_0000baa0(param_1,param_2,param_3,&local_c); 14 | return; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b3a0@0000b3a0.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000b3a0(undefined4 param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4, 3 | undefined4 param_5,undefined4 param_6) 4 | 5 | { 6 | int iVar1; 7 | int extraout_r1; 8 | undefined4 extraout_r2; 9 | undefined4 extraout_r3; 10 | undefined4 extraout_r4; 11 | undefined4 extraout_r5; 12 | int unaff_gp; 13 | 14 | iVar1 = *(int *)(unaff_gp + 0x1e84); 15 | if (iVar1 != 0xbadf00d) { 16 | FUN_00009cdc(param_1,iVar1,param_3,param_4,param_5,param_6); 17 | iVar1 = extraout_r1; 18 | param_3 = extraout_r2; 19 | param_4 = extraout_r3; 20 | param_5 = extraout_r4; 21 | param_6 = extraout_r5; 22 | } 23 | if (*(int *)(s_tryboot_00002a6c + unaff_gp) != 0xbadf00d) { 24 | FUN_00009cdc(*(int *)(s_tryboot_00002a6c + unaff_gp),iVar1,param_3,param_4,param_5,param_6); 25 | } 26 | return; 27 | } 28 | 29 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b63a@0000b63a.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Removing unreachable block (ram,0x0000b6a2) */ 3 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 4 | 5 | void FUN_0000b63a(undefined4 param_1) 6 | 7 | { 8 | uint uVar1; 9 | int unaff_gp; 10 | 11 | uVar1 = FUN_0000b0b8(); 12 | FUN_00007dca(*(undefined4 **)(unaff_gp + 0x54),(undefined4 *)&DAT_0000048e,0x200); 13 | thunk_FUN_0000d298(); 14 | if (((uVar1 & 0xe) != 0) && (*(int *)(unaff_gp + 0xac) == 0)) { 15 | FUN_0000a3e8(0x24); 16 | } 17 | FUN_00007e18((undefined4 *)0xc0020000,0,0x400); 18 | FUN_00007dca((undefined4 *)0xc0040000,(undefined4 *)(unaff_gp + 0x254),0x368); 19 | do { 20 | } while( true ); 21 | } 22 | 23 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b6be@0000b6be.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | undefined8 FUN_0000b6be(void) 5 | 6 | { 7 | return CONCAT44(_DAT_7c003008,_DAT_7c003004); 8 | } 9 | 10 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b6ca@0000b6ca.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000b6ca(void) 3 | 4 | { 5 | int iVar1; 6 | undefined4 local_8; 7 | 8 | iVar1 = FUN_0000c420(); 9 | if (iVar1 != 0) { 10 | iVar1 = FUN_0000b15c(&local_8); 11 | (**(code **)(iVar1 + 0x2c))(local_8,0x2d,1,*(code **)(iVar1 + 0x2c)); 12 | } 13 | return; 14 | } 15 | 16 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b6f0@0000b6f0.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_0000b6f0(byte *param_1,byte *param_2,int param_3) 3 | 4 | { 5 | int iVar1; 6 | uint uVar2; 7 | uint uVar3; 8 | 9 | if ((param_1 == (byte *)0x0) || (param_2 != (byte *)0x0)) { 10 | if ((param_1 == (byte *)0x0) && (param_2 != (byte *)0x0)) { 11 | return -1; 12 | } 13 | if (param_1 != (byte *)0x0 || param_2 != (byte *)0x0) { 14 | for (; ((param_3 != 0 && (uVar3 = (uint)*param_1, uVar3 != 0)) && 15 | (uVar2 = (uint)*param_2, uVar2 != 0)); param_2 = param_2 + 1) { 16 | if ((0x40 < uVar3) && (uVar3 < 0x5b)) { 17 | uVar3 = uVar3 + 0x20 & 0xff; 18 | } 19 | if ((0x40 < uVar2) && (uVar2 < 0x5b)) { 20 | uVar2 = uVar2 + 0x20 & 0xff; 21 | } 22 | if (uVar3 != uVar2) { 23 | return uVar3 - uVar2; 24 | } 25 | param_1 = param_1 + 1; 26 | param_3 = param_3 + -1; 27 | } 28 | if (param_3 != 0) { 29 | if ((*param_1 != 0) && (*param_2 == 0)) goto LAB_0000b762; 30 | if ((*param_1 == 0) && (*param_2 != 0)) { 31 | return -1; 32 | } 33 | } 34 | } 35 | iVar1 = 0; 36 | } 37 | else { 38 | LAB_0000b762: 39 | iVar1 = 1; 40 | } 41 | return iVar1; 42 | } 43 | 44 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b774@0000b774.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_0000b774(byte *param_1,undefined4 *param_2,int param_3) 3 | 4 | { 5 | byte bVar1; 6 | int iVar2; 7 | 8 | bVar1 = *param_1; 9 | if (bVar1 == 0x2d) { 10 | param_1 = param_1 + 1; 11 | } 12 | iVar2 = FUN_0000b7b6(param_1,param_2,param_3); 13 | if (bVar1 == 0x2d) { 14 | iVar2 = -iVar2; 15 | } 16 | return iVar2; 17 | } 18 | 19 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b794@0000b794.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000b794(byte *param_1,byte param_2) 3 | 4 | { 5 | byte *pbVar1; 6 | 7 | while( true ) { 8 | pbVar1 = param_1 + 1; 9 | *param_1 = param_2; 10 | if (pbVar1 == (byte *)0x0) { 11 | return; 12 | } 13 | param_2 = *pbVar1; 14 | if (param_2 == 0) break; 15 | param_1 = pbVar1; 16 | if ((0x40 < param_2) && (param_2 < 0x5b)) { 17 | FUN_0000b794(pbVar1,param_2 + 0x20); 18 | return; 19 | } 20 | } 21 | return; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b798@0000b798.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000b798(byte *param_1) 3 | 4 | { 5 | byte bVar1; 6 | 7 | while( true ) { 8 | if (param_1 == (byte *)0x0) { 9 | return; 10 | } 11 | bVar1 = *param_1; 12 | if (bVar1 == 0) break; 13 | if ((0x40 < bVar1) && (bVar1 < 0x5b)) { 14 | FUN_0000b794(param_1,bVar1 + 0x20); 15 | return; 16 | } 17 | *param_1 = bVar1; 18 | param_1 = param_1 + 1; 19 | } 20 | return; 21 | } 22 | 23 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b7b6@0000b7b6.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_0000b7b6(byte *param_1,undefined4 *param_2,int param_3) 3 | 4 | { 5 | bool bVar1; 6 | int iVar2; 7 | uint uVar3; 8 | byte bVar4; 9 | uint uVar5; 10 | 11 | iVar2 = 0; 12 | uVar3 = (uint)(param_3 == 0x10); 13 | bVar1 = false; 14 | if (param_1 == (byte *)0x0) goto LAB_0000b81c; 15 | for (; (bVar4 = *param_1, bVar4 == 9 || (bVar4 == 0x20)); param_1 = param_1 + 1) { 16 | } 17 | if (bVar4 == 0) goto LAB_0000b81c; 18 | if (bVar4 == 0x2b) { 19 | LAB_0000b7e8: 20 | param_1 = param_1 + 1; 21 | bVar4 = *param_1; 22 | } 23 | else if (bVar4 == 0x2d) { 24 | bVar1 = true; 25 | goto LAB_0000b7e8; 26 | } 27 | if (bVar4 == 0x30) { 28 | uVar5 = (uint)param_1[1]; 29 | if ((0x40 < uVar5) && (uVar5 < 0x5b)) { 30 | uVar5 = uVar5 + 0x20; 31 | } 32 | if ((uVar5 == 0x78) && (param_3 == 0 || param_3 == 0x10)) { 33 | uVar3 = 1; 34 | param_1 = param_1 + 2; 35 | } 36 | } 37 | iVar2 = FUN_0000aae4(param_1,param_2,uVar3); 38 | LAB_0000b81c: 39 | if (bVar1) { 40 | iVar2 = -iVar2; 41 | } 42 | return iVar2; 43 | } 44 | 45 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b824@0000b824.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_0000b824(float param_1,int param_2) 3 | 4 | { 5 | return (int)FLOOR(param_1 * (float)(1 << param_2) + 8.0); 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b83c@0000b83c.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000b83c(void) 3 | 4 | { 5 | return 0x4230f27c; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b844@0000b844.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000b844(uint param_1,undefined *param_2) 3 | 4 | { 5 | int iVar1; 6 | float fVar2; 7 | uint uVar3; 8 | 9 | iVar1 = 0; 10 | for (fVar2 = 1.0; fVar2 <= (float)(int)param_1; fVar2 = fVar2 * 25.0) { 11 | } 12 | uVar3 = (uint)FLOOR(fVar2 / 25.0); 13 | if (uVar3 == 0) { 14 | *param_2 = 0x30; 15 | iVar1 = 1; 16 | } 17 | for (; uVar3 != 0; uVar3 = uVar3 / 10) { 18 | param_2[iVar1] = (char)(param_1 / uVar3) + '0'; 19 | iVar1 = iVar1 + 1; 20 | param_1 = param_1 - (param_1 / uVar3) * uVar3; 21 | } 22 | param_2[iVar1] = 0; 23 | return; 24 | } 25 | 26 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b898@0000b898.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000b898(void) 3 | 4 | { 5 | code *UNRECOVERED_JUMPTABLE; 6 | int unaff_gp; 7 | 8 | UNRECOVERED_JUMPTABLE = *(code **)(*(int *)(unaff_gp + 0x124) + 0xd8); 9 | /* WARNING: Could not recover jumptable at 0x0000b8a0. Too many branches */ 10 | /* WARNING: Treating indirect jump as call */ 11 | (*UNRECOVERED_JUMPTABLE)(UNRECOVERED_JUMPTABLE); 12 | return; 13 | } 14 | 15 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b8a2@0000b8a2.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000b8a2(void) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | return *(undefined4 *)(unaff_gp + 0x124); 8 | } 9 | 10 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000b8a8@0000b8a8.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000b8a8(undefined4 *param_1) 3 | 4 | { 5 | *param_1 = 0x4000; 6 | return 0xc060e000; 7 | } 8 | 9 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000ba74@0000ba74.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000ba74(void) 3 | 4 | { 5 | code *pcVar1; 6 | uint uVar2; 7 | 8 | uVar2 = version(); 9 | if ((uVar2 >> 4 & 0xff) < 0x17) { 10 | do { 11 | pcVar1 = (code *)swi(0xe); 12 | (*pcVar1)(); 13 | } while( true ); 14 | } 15 | return; 16 | } 17 | 18 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000ba8c@0000ba8c.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000ba8c(byte *param_1,uint *param_2) 3 | 4 | { 5 | FUN_0000babc(&LAB_0000e14e,0,0x100000,param_1,param_2); 6 | return; 7 | } 8 | 9 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000baa0@0000baa0.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000baa0(int param_1,uint param_2,byte *param_3,uint *param_4) 3 | 4 | { 5 | FUN_0000babc(&LAB_0000dde0,param_1,param_2,param_3,param_4); 6 | return; 7 | } 8 | 9 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000bbee@0000bbee.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000bbee(void) 3 | 4 | { 5 | uint unaff_r7; 6 | int unaff_r8; 7 | code *unaff_r10; 8 | int unaff_r11; 9 | undefined4 unaff_r12; 10 | char *unaff_r13; 11 | int iVar1; 12 | uint uVar2; 13 | 14 | uVar2 = *(uint *)(unaff_r11 + -4); 15 | iVar1 = 0; 16 | do { 17 | FUN_0000b844(uVar2 >> 0x18,unaff_r13); 18 | FUN_000099ea(unaff_r8,unaff_r10,unaff_r12,unaff_r7,unaff_r13); 19 | if (iVar1 < 3) { 20 | (*unaff_r10)(); 21 | } 22 | uVar2 = uVar2 << 8; 23 | iVar1 = iVar1 + 1; 24 | } while (iVar1 < 4); 25 | FUN_0000bae2(); 26 | return; 27 | } 28 | 29 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000beda@0000beda.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000beda(uint param_1) 3 | 4 | { 5 | code *pcVar1; 6 | int iVar2; 7 | int extraout_r3; 8 | int iVar3; 9 | int extraout_r4; 10 | uint uVar4; 11 | int *unaff_r8; 12 | undefined unaff_r9; 13 | int unaff_gp; 14 | 15 | if (*unaff_r8 != 0) { 16 | uVar4 = unaff_r8[2] - 1U; 17 | if (param_1 < unaff_r8[2] - 1U) { 18 | uVar4 = param_1; 19 | } 20 | *(undefined *)(*unaff_r8 + uVar4) = unaff_r9; 21 | } 22 | iVar2 = *(int *)(unaff_gp + 0x1e84); 23 | iVar3 = *(int *)(s_tryboot_00002a6c + unaff_gp); 24 | while ((iVar2 != 0xbadf00d || (iVar3 != 0xbadf00d))) { 25 | pcVar1 = (code *)swi(0xe); 26 | (*pcVar1)(); 27 | iVar2 = extraout_r3; 28 | iVar3 = extraout_r4; 29 | } 30 | return; 31 | } 32 | 33 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000bf1c@0000bf1c.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_0000bf1c(int param_1) 5 | 6 | { 7 | int unaff_gp; 8 | 9 | do { 10 | } while (param_1 != 0); 11 | *(undefined4 *)(unaff_gp + 0xf8) = *(undefined4 *)(unaff_gp + 0xf8); 12 | return; 13 | } 14 | 15 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000bf38@0000bf38.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000bf38(int param_1,int param_2) 3 | 4 | { 5 | char *pcVar1; 6 | bool bVar2; 7 | undefined3 extraout_var; 8 | uint *puVar3; 9 | int extraout_r4; 10 | byte *extraout_r5; 11 | int unaff_gp; 12 | 13 | pcVar1 = *(char **)(*(int *)(unaff_gp + 0xfc) + param_1 * 4); 14 | if (*(int *)(pcVar1 + 0x30) != 0) { 15 | bVar2 = FUN_00001ebe(pcVar1); 16 | if ((CONCAT31(extraout_var,bVar2) == 0 || extraout_r4 == 0) || (param_2 != 0)) { 17 | puVar3 = *(uint **)(extraout_r5 + 0x30); 18 | *puVar3 = *(uint *)(extraout_r5 + 0x48) | *puVar3 | 0x5a000000; 19 | if (*(int *)(extraout_r5 + 0x4c) != 0 && extraout_r4 != 0) { 20 | do { 21 | } while ((*(uint *)(extraout_r5 + 0x4c) & *puVar3) == 0); 22 | } 23 | } 24 | else { 25 | FUN_000009b8(extraout_r5,0); 26 | } 27 | } 28 | return; 29 | } 30 | 31 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000bf98@0000bf98.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000bf98(int param_1) 3 | 4 | { 5 | byte *pbVar1; 6 | bool bVar2; 7 | undefined3 extraout_var; 8 | int extraout_r4; 9 | int unaff_gp; 10 | 11 | pbVar1 = *(byte **)(*(int *)(unaff_gp + 0xfc) + param_1 * 4); 12 | if (*(int *)(pbVar1 + 0x30) != 0) { 13 | bVar2 = FUN_00001ebe((char *)pbVar1); 14 | if (CONCAT31(extraout_var,bVar2) != 0 && extraout_r4 != 0) { 15 | FUN_000009b8(pbVar1,1); 16 | FUN_000009b8(pbVar1,0); 17 | } 18 | **(uint **)(pbVar1 + 0x30) = **(uint **)(pbVar1 + 0x30) & ~*(uint *)(pbVar1 + 0x48) | 0x5a000000 19 | ; 20 | } 21 | return; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c042@0000c042.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Removing unreachable block (ram,0x0000c0a6) */ 3 | /* WARNING: Removing unreachable block (ram,0x0000c0aa) */ 4 | /* WARNING: Removing unreachable block (ram,0x0000c0b0) */ 5 | 6 | void FUN_0000c042(int param_1) 7 | 8 | { 9 | /* WARNING: Do nothing block with infinite loop */ 10 | do { 11 | } while( true ); 12 | } 13 | 14 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c162@0000c162.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000c162(uint *param_1,int param_2,int param_3) 3 | 4 | { 5 | uint *puVar1; 6 | uint *puVar2; 7 | uint *puVar3; 8 | int unaff_gp; 9 | 10 | puVar3 = *(uint **)(unaff_gp + 0x5f4 + param_2 * 4); 11 | puVar2 = (uint *)0x0; 12 | while (puVar1 = puVar3, puVar1 != (uint *)0x0) { 13 | if (param_3 == 0) { 14 | if (*puVar1 <= *param_1) break; 15 | } 16 | else if (*param_1 <= *puVar1) break; 17 | puVar2 = puVar1; 18 | puVar3 = (uint *)puVar1[2]; 19 | } 20 | param_1[2] = (uint)puVar1; 21 | if (puVar2 == (uint *)0x0) { 22 | *(uint **)(unaff_gp + 0x5f4 + param_2 * 4) = param_1; 23 | } 24 | else { 25 | puVar2[2] = (uint)param_1; 26 | } 27 | return; 28 | } 29 | 30 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c1b2@0000c1b2.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000c1b2(void) 3 | 4 | { 5 | int unaff_gp; 6 | uint auStack_2b0 [169]; 7 | 8 | *(undefined4 *)(&DAT_00002d14 + unaff_gp) = 1; 9 | FUN_00002b62(auStack_2b0,(int)(s_death_blacksite_alephvoid_com_00001054 + unaff_gp),6,0); 10 | FUN_0000adac(auStack_2b0,*(uint **)(unaff_gp + 0x174)); 11 | FUN_00002756((int)auStack_2b0); 12 | FUN_00001078((int)(s_death_blacksite_alephvoid_com_00001054 + unaff_gp)); 13 | return; 14 | } 15 | 16 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c1f4@0000c1f4.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000c1f4(uint *param_1,int param_2) 3 | 4 | { 5 | int iVar1; 6 | int extraout_r1; 7 | uint uVar2; 8 | int extraout_r3; 9 | uint uVar3; 10 | 11 | uVar2 = *param_1; 12 | while( true ) { 13 | if (*(uint *)(param_2 + 8) <= uVar2) { 14 | return 4; 15 | } 16 | uVar2 = (uint)*(byte *)(*(int *)(param_2 + 4) + uVar2); 17 | if (uVar2 == 0) { 18 | return 7; 19 | } 20 | iVar1 = FUN_00002cec(uVar2); 21 | if (iVar1 != 0) { 22 | return 1; 23 | } 24 | if (extraout_r3 == 0x3d) break; 25 | uVar2 = *param_1 + 1; 26 | *param_1 = uVar2; 27 | uVar3 = param_1[0x58] + 1; 28 | *(char *)((int)param_1 + param_1[0x58] + 0x3d) = (char)extraout_r3; 29 | param_1[0x58] = uVar3; 30 | param_2 = extraout_r1; 31 | if (0x20 < uVar3) { 32 | return 1; 33 | } 34 | } 35 | return 1; 36 | } 37 | 38 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c242@0000c242.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | undefined4 5 | FUN_0000c242(uint param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4, 6 | undefined4 param_5,undefined4 param_6) 7 | 8 | { 9 | int iVar1; 10 | undefined4 extraout_r1; 11 | undefined4 extraout_r2; 12 | undefined4 extraout_r3; 13 | undefined4 extraout_r4; 14 | undefined4 extraout_r5; 15 | undefined4 uVar2; 16 | int unaff_gp; 17 | 18 | if (0xbf < param_1) { 19 | FUN_00009cdc(param_1,param_2,param_3,param_4,param_5,param_6); 20 | } 21 | if (*(int *)(unaff_gp + 0xf4) == 0) { 22 | FUN_0000cc94(); 23 | _DAT_7d00f020 = param_1; 24 | FUN_0000bf1c(10); 25 | iVar1 = FUN_000098fe(0); 26 | uVar2 = _DAT_7d00f010; 27 | if (iVar1 != 0) { 28 | FUN_00009cdc(iVar1,extraout_r1,extraout_r2,extraout_r3,extraout_r4,extraout_r5); 29 | uVar2 = 0; 30 | } 31 | FUN_000026a0(); 32 | } 33 | else { 34 | uVar2 = *(undefined4 *)(unaff_gp + 0x5854 + param_1 * 4); 35 | if ((0x3c < param_1) && (param_1 < 0x41)) { 36 | *(undefined4 *)(unaff_gp + 0x5854 + param_1 * 4) = 0; 37 | } 38 | } 39 | return uVar2; 40 | } 41 | 42 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c2ae@0000c2ae.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000c2ae(uint *param_1,int param_2) 3 | 4 | { 5 | uint uVar1; 6 | char cVar2; 7 | uint uVar3; 8 | uint uVar4; 9 | 10 | uVar4 = *param_1; 11 | uVar3 = *(uint *)(param_2 + 8); 12 | do { 13 | do { 14 | if (uVar3 <= uVar4) { 15 | return 6; 16 | } 17 | cVar2 = *(char *)(*(int *)(param_2 + 4) + uVar4); 18 | uVar4 = uVar4 + 1; 19 | *param_1 = uVar4; 20 | *(undefined *)((int)param_1 + 0x11) = 4; 21 | if (cVar2 == '\0') { 22 | return 7; 23 | } 24 | uVar1 = param_1[0x5a]; 25 | } while ((uVar1 == 0) && (cVar2 == ' ' || cVar2 == '\t')); 26 | if (cVar2 == ']' || cVar2 == '\n') { 27 | return 1; 28 | } 29 | *(char *)((int)param_1 + uVar1 + 0x1c) = cVar2; 30 | param_1[0x5a] = uVar1 + 1; 31 | } while (uVar1 + 1 < 0x21); 32 | return 1; 33 | } 34 | 35 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c308@0000c308.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000c308(uint *param_1,int param_2) 3 | 4 | { 5 | uint uVar1; 6 | char cVar2; 7 | uint uVar3; 8 | uint uVar4; 9 | 10 | uVar4 = *param_1; 11 | uVar3 = *(uint *)(param_2 + 8); 12 | while( true ) { 13 | do { 14 | if (uVar3 <= uVar4) { 15 | return 5; 16 | } 17 | cVar2 = *(char *)(*(int *)(param_2 + 4) + uVar4); 18 | uVar4 = uVar4 + 1; 19 | *param_1 = uVar4; 20 | uVar1 = param_1[0x59]; 21 | } while (((uVar1 == 0) && (cVar2 == ' ' || cVar2 == '\t')) || 22 | (*(undefined *)((int)param_1 + 0x11) = 2, cVar2 == '\r')); 23 | if (cVar2 == '\n') break; 24 | *(char *)((int)param_1 + uVar1 + 0x5e) = cVar2; 25 | param_1[0x59] = uVar1 + 1; 26 | if (0xff < (int)(uVar1 + 1)) { 27 | return 1; 28 | } 29 | } 30 | return 1; 31 | } 32 | 33 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c35e@0000c35e.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000c35e(int param_1) 3 | 4 | { 5 | FUN_00007e18((undefined4 *)(param_1 + 0x3d),0,0x21); 6 | *(undefined4 *)(param_1 + 0x160) = 0; 7 | FUN_00007e18((undefined4 *)(param_1 + 0x5e),0,0x101); 8 | *(undefined4 *)(param_1 + 0x164) = 0; 9 | *(undefined4 *)(param_1 + 0x2a0) = 0; 10 | *(undefined *)(param_1 + 0x11) = 0; 11 | return; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c392@0000c392.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_0000c392(int param_1) 3 | 4 | { 5 | int iVar1; 6 | int iVar2; 7 | uint uVar3; 8 | 9 | FUN_0000c506(param_1,0); 10 | iVar1 = FUN_0000b8a2(); 11 | iVar1 = (**(code **)(iVar1 + 0x40))(0); 12 | if (iVar1 != 0) { 13 | iVar2 = FUN_0000b8a2(); 14 | (**(code **)(iVar2 + 0x44))(iVar1,0x43,*(code **)(iVar2 + 0x44)); 15 | FUN_0000c612(iVar1,0); 16 | uVar3 = FUN_0000c4b4(iVar1); 17 | if (uVar3 == 0x20001927) { 18 | return iVar1; 19 | } 20 | } 21 | if (iVar1 != 0) { 22 | iVar2 = FUN_0000b8a2(); 23 | (**(code **)(iVar2 + 0x3c))(iVar1,*(code **)(iVar2 + 0x3c)); 24 | } 25 | return 0; 26 | } 27 | 28 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c3e6@0000c3e6.c: -------------------------------------------------------------------------------- 1 | 2 | undefined * FUN_0000c3e6(int param_1) 3 | 4 | { 5 | return (&PTR_DAT_0000f818)[param_1 * 2] + 0x40000000; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c3f8@0000c3f8.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000c3f8(void) 3 | 4 | { 5 | int iVar1; 6 | undefined4 uVar2; 7 | int unaff_gp; 8 | 9 | iVar1 = FUN_0000c392((uint)(*(int *)(unaff_gp + 0x104) == 0)); 10 | *(int *)(unaff_gp + 0x60) = iVar1; 11 | if (iVar1 == 0) { 12 | uVar2 = 0xffffffff; 13 | } 14 | else { 15 | *(undefined4 *)(unaff_gp + 0x104) = 1; 16 | uVar2 = 0; 17 | } 18 | return uVar2; 19 | } 20 | 21 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c420@0000c420.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000c420(void) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | return *(undefined4 *)(unaff_gp + 0x104); 8 | } 9 | 10 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c426@0000c426.c: -------------------------------------------------------------------------------- 1 | 2 | uint FUN_0000c426(undefined4 param_1,uint param_2) 3 | 4 | { 5 | byte local_8; 6 | byte local_7; 7 | byte local_6; 8 | byte local_5; 9 | 10 | FUN_0000c454(param_1,param_2,&local_8,4); 11 | return (uint)local_8 | (uint)local_7 << 8 | (uint)local_6 << 0x10 | (uint)local_5 << 0x18; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c454@0000c454.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000c454(undefined4 param_1,uint param_2,undefined4 param_3,undefined4 param_4) 3 | 4 | { 5 | undefined4 uVar1; 6 | int iVar2; 7 | undefined local_18; 8 | undefined local_17; 9 | undefined local_16; 10 | undefined local_15; 11 | 12 | if ((param_2 & 3) == 0) { 13 | local_18 = (undefined)(param_2 >> 0x18); 14 | local_17 = (undefined)(param_2 >> 0x10); 15 | local_16 = (undefined)(param_2 >> 8); 16 | local_15 = (undefined)param_2; 17 | iVar2 = FUN_0000b8a2(); 18 | (**(code **)(iVar2 + 0x58))(param_1,0xff,&local_18,4); 19 | iVar2 = FUN_0000b8a2(); 20 | uVar1 = (**(code **)(iVar2 + 0x4c))(param_1,0xff,param_3,param_4,*(code **)(iVar2 + 0x4c)); 21 | } 22 | else { 23 | uVar1 = 0xffffffff; 24 | } 25 | return uVar1; 26 | } 27 | 28 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c4b4@0000c4b4.c: -------------------------------------------------------------------------------- 1 | 2 | uint FUN_0000c4b4(undefined4 param_1) 3 | 4 | { 5 | uint uVar1; 6 | undefined4 extraout_r2; 7 | undefined4 extraout_r3; 8 | undefined4 extraout_r4; 9 | undefined4 extraout_r5; 10 | 11 | FUN_0000c55c(param_1,0x40017004,0x800000); 12 | uVar1 = FUN_0000c426(param_1,0x40000000); 13 | _write_to_stdout((byte *)s_RP1_BOOT_chip_ID__0x_08x_0000c4e0,uVar1,extraout_r2,extraout_r3, 14 | extraout_r4,extraout_r5); 15 | return uVar1; 16 | } 17 | 18 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c4fa@0000c4fa.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000c4fa(int param_1,int param_2) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | FUN_0000c426(*(undefined4 *)(unaff_gp + 0x60),param_2 + param_1); 8 | return; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c506@0000c506.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000c506(int param_1,int param_2) 3 | 4 | { 5 | int iVar1; 6 | 7 | iVar1 = FUN_0000b8a2(); 8 | (**(code **)(iVar1 + 0x24))(0x3ea,0x3ea,0x10,*(code **)(iVar1 + 0x24)); 9 | if (param_1 != 0) { 10 | iVar1 = FUN_0000b8a2(); 11 | (**(code **)(iVar1 + 0x30))(0x3ea,0,*(code **)(iVar1 + 0x30)); 12 | FUN_0000bf1c(100); 13 | } 14 | iVar1 = FUN_0000b8a2(); 15 | (**(code **)(iVar1 + 0x30))(0x3ea,1); 16 | if (param_2 == 0) { 17 | FUN_0000bf1c(100); 18 | } 19 | if (param_1 != 0) { 20 | FUN_0000bf1c(3000); 21 | } 22 | return; 23 | } 24 | 25 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c55c@0000c55c.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000c55c(undefined4 param_1,uint param_2,undefined4 param_3) 3 | 4 | { 5 | undefined4 local_4; 6 | 7 | local_4 = param_3; 8 | FUN_0000c572(param_1,param_2,&local_4,4); 9 | return; 10 | } 11 | 12 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c612@0000c612.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000c612(undefined4 param_1,undefined4 param_2) 3 | 4 | { 5 | FUN_0000c55c(param_1,0,param_2); 6 | return; 7 | } 8 | 9 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c61a@0000c61a.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000c61a(int param_1,int param_2,undefined4 param_3) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | FUN_0000c55c(*(undefined4 *)(unaff_gp + 0x60),param_2 + param_1,param_3); 8 | return; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c77a@0000c77a.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000c77a(int param_1) 3 | 4 | { 5 | int iVar1; 6 | undefined4 uVar2; 7 | 8 | FUN_0000e552(param_1,0,param_1 + 8,8); 9 | iVar1 = FUN_0000433c(param_1,0); 10 | if (((iVar1 << 0x19) >> 0x19 == 0xc) && (*(int *)(param_1 + 0x24) == 0)) { 11 | uVar2 = 0; 12 | } 13 | else { 14 | uVar2 = 0xffffffff; 15 | } 16 | return uVar2; 17 | } 18 | 19 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c7a8@0000c7a8.c: -------------------------------------------------------------------------------- 1 | 2 | bool FUN_0000c7a8(uint *param_1,uint *param_2,int param_3) 3 | 4 | { 5 | int iVar1; 6 | uint uVar2; 7 | 8 | uVar2 = 0; 9 | for (iVar1 = (int)(((uint)(param_3 >> 1) >> 0x1e) + param_3) >> 2; 0 < iVar1; iVar1 = iVar1 + -1) 10 | { 11 | uVar2 = uVar2 | *param_2 ^ *param_1; 12 | param_1 = param_1 + 1; 13 | param_2 = param_2 + 1; 14 | } 15 | return uVar2 != 0; 16 | } 17 | 18 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c7f4@0000c7f4.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000c7f4(void) 3 | 4 | { 5 | return; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c7f6@0000c7f6.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | undefined4 FUN_0000c7f6(void) 5 | 6 | { 7 | undefined4 uVar1; 8 | int iVar2; 9 | 10 | iVar2 = 10; 11 | _DAT_7c020554 = _DAT_7c020554 & 0xfffffffc; 12 | _DAT_7c021154 = _DAT_7c021154 & 0xfffffffc; 13 | while (((_DAT_7c001090 & _DAT_7c001090 & 0x80000000) == 0 && (iVar2 = iVar2 + -1, iVar2 != 0))) { 14 | FUN_0000bf1c(1000); 15 | } 16 | uVar1 = 0; 17 | if ((_DAT_7c001090 & _DAT_7c001090 & 0x80000000) == 0) { 18 | uVar1 = 0xffffffff; 19 | } 20 | return uVar1; 21 | } 22 | 23 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c854@0000c854.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | uint FUN_0000c854(uint param_1,int param_2,int param_3) 5 | 6 | { 7 | int iVar1; 8 | uint uVar2; 9 | uint extraout_r5; 10 | uint uVar3; 11 | 12 | iVar1 = FUN_0000c7f6(); 13 | uVar3 = 0xffffffff; 14 | if (iVar1 == 0) { 15 | if (param_2 == 0) { 16 | uVar2 = 0; 17 | } 18 | else { 19 | uVar2 = 0x1000000; 20 | } 21 | if (param_3 == 0) { 22 | _DAT_7c001090 = 0; 23 | } 24 | else { 25 | _DAT_7c001090 = 0x4000000; 26 | } 27 | _DAT_7c001090 = _DAT_7c001090 | param_1 & 0x7f | uVar2; 28 | iVar1 = 10; 29 | while (((_DAT_7c001090 & 0x80000000) == 0 && (iVar1 = iVar1 + -1, iVar1 != 0))) { 30 | FUN_0000bf1c(1000); 31 | uVar2 = extraout_r5; 32 | } 33 | if ((_DAT_7c001090 & 0x40000000) == 0) { 34 | uVar3 = (_DAT_7c001090 & 0xff0000) >> 0x10; 35 | } 36 | else { 37 | _sprintf_to_stdout((byte *)s_SD_MR__08x_R_timeout__d__d__d_rd_0000c8d0,_DAT_7c001090,param_1, 38 | param_2,param_3,uVar2); 39 | } 40 | } 41 | FUN_0000c7f4(); 42 | return uVar3; 43 | } 44 | 45 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000c8fc@0000c8fc.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_0000c8fc(uint param_1,int param_2,int param_3,uint param_4) 5 | 6 | { 7 | int iVar1; 8 | uint uVar2; 9 | int iVar3; 10 | 11 | iVar1 = FUN_0000c7f6(); 12 | iVar3 = 10; 13 | if (iVar1 == 0) { 14 | if (param_2 == 0) { 15 | uVar2 = 0; 16 | } 17 | else { 18 | uVar2 = 0x1000000; 19 | } 20 | if (param_3 == 0) { 21 | _DAT_7c001090 = 0; 22 | } 23 | else { 24 | _DAT_7c001090 = 0x4000000; 25 | } 26 | _DAT_7c001090 = _DAT_7c001090 | (param_4 & 0xff) << 8 | param_1 & 0x7f | uVar2 | 0x20000000; 27 | while (((_DAT_7c001090 & 0x80000000) == 0 && (iVar3 = iVar3 + -1, iVar3 != 0))) { 28 | FUN_0000bf1c(1000); 29 | } 30 | } 31 | FUN_0000c7f4(); 32 | return; 33 | } 34 | 35 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000ca68@0000ca68.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000ca68(undefined4 param_1,undefined4 *param_2,undefined4 *param_3) 3 | 4 | { 5 | int iVar1; 6 | undefined4 uVar2; 7 | undefined4 extraout_r4; 8 | 9 | if (param_3 != (undefined4 *)0x0) { 10 | *param_3 = 0; 11 | } 12 | iVar1 = FUN_0000b8a2(); 13 | uVar2 = (**(code **)(iVar1 + 0x84))(extraout_r4); 14 | *param_2 = uVar2; 15 | return 0; 16 | } 17 | 18 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000ca88@0000ca88.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000ca88(int param_1,int param_2,int param_3,undefined4 param_4,undefined4 param_5, 3 | undefined4 param_6) 4 | 5 | { 6 | undefined4 uVar1; 7 | int iVar2; 8 | undefined4 *puVar3; 9 | undefined4 *puVar4; 10 | 11 | switch(param_2) { 12 | case 1: 13 | iVar2 = *(int *)(param_1 + 0x3c); 14 | break; 15 | case 2: 16 | iVar2 = *(int *)(param_1 + 0x38); 17 | break; 18 | case 3: 19 | iVar2 = *(int *)(param_1 + 0x34); 20 | break; 21 | default: 22 | FUN_00009cdc(param_1,param_2 + -1,param_3,param_1,param_5,param_6); 23 | return; 24 | } 25 | puVar4 = (undefined4 *)(iVar2 + 0xc); 26 | puVar3 = (undefined4 *)(param_3 + 0xc); 27 | iVar2 = 3; 28 | do { 29 | uVar1 = *puVar4; 30 | puVar4 = puVar4 + -1; 31 | *puVar3 = uVar1; 32 | puVar3 = puVar3 + -1; 33 | iVar2 = iVar2 + -1; 34 | } while (-1 < iVar2); 35 | return; 36 | } 37 | 38 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000cac2@0000cac2.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000cac2(int param_1,int param_2,int param_3,undefined4 param_4,undefined4 param_5, 3 | undefined4 param_6) 4 | 5 | { 6 | uint uVar1; 7 | int iVar2; 8 | uint *puVar3; 9 | uint *puVar4; 10 | 11 | switch(param_2) { 12 | case 1: 13 | iVar2 = *(int *)(param_1 + 0x3c); 14 | break; 15 | case 2: 16 | iVar2 = *(int *)(param_1 + 0x38); 17 | break; 18 | case 3: 19 | iVar2 = *(int *)(param_1 + 0x34); 20 | break; 21 | default: 22 | FUN_00009cdc(param_1,param_2 + -1,param_3,param_1,param_5,param_6); 23 | return; 24 | } 25 | puVar4 = (uint *)(param_3 + 0xc); 26 | puVar3 = (uint *)(iVar2 + 0xc); 27 | iVar2 = 3; 28 | do { 29 | uVar1 = *puVar4; 30 | puVar4 = puVar4 + -1; 31 | *puVar3 = uVar1 | 0x5a000000; 32 | puVar3 = puVar3 + -1; 33 | iVar2 = iVar2 + -1; 34 | } while (-1 < iVar2); 35 | return; 36 | } 37 | 38 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000cb22@0000cb22.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000cb22(int param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4, 3 | undefined4 param_5,undefined4 param_6) 4 | 5 | { 6 | FUN_00004a18(0x3f1,0x3f1,0x10,param_4,param_5,param_6); 7 | FUN_00004ad4(0x3f1,(uint)(param_1 != 0)); 8 | return; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000cb46@0000cb46.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000cb46(int param_1) 3 | 4 | { 5 | uint uVar1; 6 | int iVar2; 7 | int iVar3; 8 | 9 | if ((0x3f < *(uint *)(param_1 + 0xc)) && (uVar1 = FUN_0000c854(5,0,0), uVar1 == 0xff)) { 10 | iVar3 = 0; 11 | do { 12 | iVar2 = 0; 13 | do { 14 | FUN_0000c8fc(3,iVar3,iVar2,0x2f); 15 | iVar2 = iVar2 + 1; 16 | } while (iVar2 < 2); 17 | iVar3 = iVar3 + 1; 18 | } while (iVar3 < 2); 19 | } 20 | return; 21 | } 22 | 23 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000cc1c@0000cc1c.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000cc1c(void) 3 | 4 | { 5 | uint uVar1; 6 | 7 | uVar1 = FUN_0000a2a2(); 8 | FUN_00001fbe(0x32,uVar1,0); 9 | return; 10 | } 11 | 12 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000cc62@0000cc62.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000cc62(int param_1) 3 | 4 | { 5 | int iVar1; 6 | int unaff_gp; 7 | 8 | iVar1 = *(int *)(unaff_gp + 100); 9 | if (0x3f < *(uint *)(param_1 + 0xc)) { 10 | FUN_0000cb46(*(int *)(unaff_gp + 0x40)); 11 | } 12 | FUN_00008076((undefined4 *)(unaff_gp + 0x5b7c + (uint)(iVar1 != 0) * 0x48)); 13 | return; 14 | } 15 | 16 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000cc94@0000cc94.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_0000cc94(void) 5 | 6 | { 7 | _DAT_7d00f004 = 3; 8 | FUN_0000bf1c(10); 9 | _DAT_7d00f008 = 0; 10 | FUN_0000bf1c(10); 11 | _DAT_7d00f004 = 2; 12 | FUN_0000bf1c(10); 13 | return; 14 | } 15 | 16 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000ce46@0000ce46.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000ce46(void) 3 | 4 | { 5 | uint uVar1; 6 | ulonglong uVar2; 7 | undefined8 uVar3; 8 | 9 | uVar1 = FUN_0000b83c(); 10 | uVar2 = FUN_000000a8(uVar1); 11 | uVar3 = FUN_0000039c((uint)uVar2,(int)(uVar2 >> 0x20),1000000,0); 12 | FUN_00001fbe(0x16,(uint)uVar3,(uint)((ulonglong)uVar3 >> 0x20)); 13 | return; 14 | } 15 | 16 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000ce80@0000ce80.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000ce80(uint *param_1,int param_2) 3 | 4 | { 5 | char cVar1; 6 | uint uVar2; 7 | 8 | uVar2 = *param_1; 9 | if (uVar2 < *(uint *)(param_2 + 8)) { 10 | do { 11 | cVar1 = *(char *)(*(int *)(param_2 + 4) + uVar2); 12 | if (cVar1 == '\0') { 13 | *param_1 = uVar2; 14 | return 7; 15 | } 16 | if (cVar1 == '\n') { 17 | *param_1 = uVar2; 18 | return 1; 19 | } 20 | uVar2 = uVar2 + 1; 21 | } while (uVar2 < *(uint *)(param_2 + 8)); 22 | *param_1 = uVar2; 23 | } 24 | return 2; 25 | } 26 | 27 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000ceac@0000ceac.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000ceac(uint *param_1,int param_2) 3 | 4 | { 5 | char cVar1; 6 | uint uVar2; 7 | 8 | uVar2 = *param_1; 9 | if (uVar2 < *(uint *)(param_2 + 8)) { 10 | do { 11 | cVar1 = *(char *)(*(int *)(param_2 + 4) + uVar2); 12 | if (cVar1 == '\0') { 13 | *param_1 = uVar2; 14 | return 7; 15 | } 16 | if (cVar1 == '=') { 17 | *param_1 = uVar2; 18 | return 1; 19 | } 20 | uVar2 = uVar2 + 1; 21 | } while (uVar2 < *(uint *)(param_2 + 8)); 22 | *param_1 = uVar2; 23 | } 24 | return 3; 25 | } 26 | 27 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000ced8@0000ced8.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000ced8(uint *param_1,int param_2) 3 | 4 | { 5 | uint uVar1; 6 | int iVar2; 7 | int extraout_r1; 8 | uint *extraout_r5; 9 | 10 | uVar1 = *param_1; 11 | while( true ) { 12 | if (*(uint *)(param_2 + 8) <= uVar1) { 13 | return 0; 14 | } 15 | uVar1 = (uint)*(byte *)(*(int *)(param_2 + 4) + uVar1); 16 | if (uVar1 == 0) break; 17 | iVar2 = FUN_00002cec(uVar1); 18 | if (iVar2 == 0) { 19 | return 1; 20 | } 21 | uVar1 = *extraout_r5 + 1; 22 | *extraout_r5 = uVar1; 23 | param_2 = extraout_r1; 24 | } 25 | return 7; 26 | } 27 | 28 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000d186@0000d186.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000d186(undefined *param_1,undefined4 param_2) 3 | 4 | { 5 | *param_1 = (char)((uint)param_2 >> 0x10); 6 | param_1[1] = (char)((uint)param_2 >> 8); 7 | param_1[2] = (char)param_2; 8 | return; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000d292@0000d292.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000d292(byte *param_1,byte *param_2) 3 | 4 | { 5 | FUN_0000daf0(param_1,param_2,0); 6 | return; 7 | } 8 | 9 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000d298@0000d298.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_0000d298(void) 5 | 6 | { 7 | _DAT_7d004000 = &DAT_00041000; 8 | _DAT_7d004008 = 0; 9 | return; 10 | } 11 | 12 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000d2ac@0000d2ac.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000d2ac(uint param_1,int param_2,int param_3,undefined4 param_4,uint param_5) 3 | 4 | { 5 | undefined4 *local_34; 6 | undefined4 local_30; 7 | undefined4 auStack_2c [5]; 8 | 9 | local_34 = DAT_0000ee34; 10 | local_30 = DAT_0000ee38; 11 | if (param_5 != 0) { 12 | local_34 = auStack_2c; 13 | FUN_000018fc(local_34,param_4,param_5); 14 | } 15 | FUN_0000d2f0(param_1,param_2,param_3,param_5,(int *)&local_34,0,'\0'); 16 | return; 17 | } 18 | 19 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000d4ba@0000d4ba.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000d4ba(void) 3 | 4 | { 5 | int iVar1; 6 | float fVar2; 7 | uint uVar3; 8 | uint *puVar4; 9 | int unaff_gp; 10 | 11 | puVar4 = (uint *)(unaff_gp + 0x10c); 12 | *puVar4 = 1; 13 | iVar1 = FUN_0000b8a2(); 14 | fVar2 = (float)(**(code **)(iVar1 + 0x38))(iVar1,*(code **)(iVar1 + 0x38)); 15 | uVar3 = *puVar4; 16 | while (*(uint *)(unaff_gp + 0x50) < (uint)(int)FLOOR(fVar2) / uVar3) { 17 | uVar3 = uVar3 << 1; 18 | *puVar4 = uVar3; 19 | } 20 | *(uint *)(unaff_gp + 0xd8) = uVar3; 21 | if (*(int *)(unaff_gp + 0xd4) == 0) { 22 | iVar1 = FUN_0000b8a2(); 23 | (**(code **)(iVar1 + 0x24))(1,1,0x100); 24 | iVar1 = FUN_0000b8a2(); 25 | (**(code **)(iVar1 + 0x24))(2,2,0x100,*(code **)(iVar1 + 0x24)); 26 | iVar1 = FUN_0000b8a2(); 27 | (**(code **)(iVar1 + 0x24))(3,3,0x100); 28 | iVar1 = FUN_0000b8a2(); 29 | (**(code **)(iVar1 + 0x24))(4,4,0x100,*(code **)(iVar1 + 0x24)); 30 | *(undefined4 *)(unaff_gp + 0xd4) = 1; 31 | } 32 | return 0; 33 | } 34 | 35 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000d6ce@0000d6ce.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000d6ce(void) 3 | 4 | { 5 | int iVar1; 6 | undefined4 uVar2; 7 | int unaff_gp; 8 | 9 | FUN_0000d4ba(); 10 | iVar1 = FUN_0000d2ac(0x9f,0,0,(char *)(unaff_gp + 0x78),3); 11 | if (iVar1 < 0) { 12 | FUN_0000d298(); 13 | uVar2 = 8; 14 | } 15 | else { 16 | iVar1 = thunk_FUN_0000411e((char *)(unaff_gp + 0x78)); 17 | *(int *)(unaff_gp + 0x74) = iVar1; 18 | FUN_0000d298(); 19 | uVar2 = 0; 20 | } 21 | return uVar2; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000d834@0000d834.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000d834(int param_1,uint param_2,uint param_3,int param_4,undefined4 param_5, 3 | undefined4 param_6) 4 | 5 | { 6 | int local_c; 7 | undefined4 local_8; 8 | 9 | local_8 = DAT_0000ed30; 10 | local_c = param_1; 11 | FUN_0000d968(&local_c,param_2,param_3,param_4,0,param_6); 12 | return; 13 | } 14 | 15 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000d850@0000d850.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000d850(int *param_1,int param_2,int param_3,byte *param_4,undefined4 *param_5, 3 | byte *param_6) 4 | 5 | { 6 | int local_10; 7 | undefined4 local_c; 8 | 9 | local_c = DAT_0000ee08; 10 | local_10 = param_2; 11 | FUN_0000d86c(param_1,&local_10,param_3,param_4,param_5,param_6,0); 12 | return; 13 | } 14 | 15 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000d968@0000d968.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 3 | FUN_0000d968(int *param_1,uint param_2,uint param_3,int param_4,int param_5,undefined4 param_6) 4 | 5 | { 6 | uint uVar1; 7 | int extraout_r4; 8 | int extraout_r5; 9 | undefined4 uVar2; 10 | int unaff_gp; 11 | undefined auStack_20 [3]; 12 | undefined local_1d; 13 | 14 | FUN_0000189e((int *)*param_1,param_2,param_3,param_4,param_5,param_6); 15 | FUN_0000d4ba(); 16 | uVar2 = 4; 17 | if (*(uint *)(unaff_gp + 0x74) < param_3 + param_2) { 18 | uVar2 = 3; 19 | } 20 | else { 21 | FUN_0000d186(auStack_20,param_2); 22 | local_1d = 0; 23 | uVar1 = FUN_0000d2f0(0xb,extraout_r4,4,param_3,param_1,extraout_r5,(char)param_5); 24 | if (-1 < (int)uVar1) { 25 | uVar2 = 0; 26 | } 27 | } 28 | FUN_0000d298(); 29 | return uVar2; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000d9c4@0000d9c4.c: -------------------------------------------------------------------------------- 1 | 2 | uint FUN_0000d9c4(void) 3 | 4 | { 5 | int iVar1; 6 | int extraout_r4; 7 | uint uVar2; 8 | int unaff_gp; 9 | uint local_18; 10 | uint local_14; 11 | undefined auStack_10 [4]; 12 | 13 | iVar1 = *(int *)(unaff_gp + 0x74); 14 | FUN_0000d4ba(); 15 | FUN_0000d186(auStack_10,iVar1 + -8); 16 | iVar1 = FUN_0000d2ac(3,extraout_r4,3,&local_18,8); 17 | if (((iVar1 < 0) || (local_18 != ~local_14)) || (uVar2 = local_14, local_14 == 0xffffffff)) { 18 | uVar2 = 0; 19 | } 20 | FUN_0000d298(); 21 | return uVar2; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000daca@0000daca.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000daca(int param_1,int param_2) 3 | 4 | { 5 | byte local_8 [4]; 6 | byte local_4 [4]; 7 | 8 | local_8[0] = (byte)param_1; 9 | local_4[0] = (byte)param_2; 10 | if ((param_2 != 0) && (param_1 != 0x3f)) { 11 | FUN_0000daf0(local_8,local_4,1); 12 | } 13 | return; 14 | } 15 | 16 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000dc48@0000dc48.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000dc48(void) 3 | 4 | { 5 | int iVar1; 6 | uint extraout_r1; 7 | undefined4 extraout_r2; 8 | undefined4 extraout_r3; 9 | undefined4 extraout_r4; 10 | undefined4 extraout_r5; 11 | 12 | iVar1 = FUN_0000af30(&LAB_0000d72a,0,100000,1000); 13 | if (iVar1 < 0) { 14 | _sprintf_to_stdout((byte *)s_SPI_WEL_timeout_0000dc70,extraout_r1,extraout_r2,extraout_r3, 15 | extraout_r4,extraout_r5); 16 | } 17 | return; 18 | } 19 | 20 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000dc80@0000dc80.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | undefined4 FUN_0000dc80(undefined *param_1,int *param_2,undefined4 param_3,uint param_4) 5 | 6 | { 7 | code *pcVar1; 8 | int iVar2; 9 | uint uVar3; 10 | uint uVar4; 11 | int unaff_gp; 12 | 13 | if (0 < *param_2) { 14 | if (param_2[1] == 0) { 15 | _DAT_7d004004 = 0; 16 | param_2[1] = 1; 17 | param_4 = 0; 18 | } 19 | do { 20 | uVar3 = param_4; 21 | if ((_DAT_7d004000 & 0x20000) != 0) { 22 | *param_1 = (char)_DAT_7d004004; 23 | iVar2 = *param_2; 24 | *param_2 = iVar2 + -1; 25 | if (iVar2 + -1 == 0) { 26 | return 0; 27 | } 28 | _DAT_7d004004 = 0; 29 | return 0; 30 | } 31 | uVar4 = _DAT_7c003004 - *(int *)(unaff_gp + 0x110); 32 | param_4 = _DAT_7d004000; 33 | } while (uVar4 < 0x989681); 34 | _sprintf_to_stdout((byte *)s_SPI_ERROR___d_CS__08_0000dcf0,0x52,_DAT_7d004000,uVar3, 35 | _DAT_7c003004,uVar4); 36 | pcVar1 = (code *)swi(0xe); 37 | (*pcVar1)(); 38 | } 39 | return 0xffffffff; 40 | } 41 | 42 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000dd06@0000dd06.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000dd06(undefined param_1,int *param_2) 3 | 4 | { 5 | int iVar1; 6 | int iVar2; 7 | int iVar3; 8 | 9 | iVar3 = param_2[1]; 10 | while( true ) { 11 | iVar1 = *(int *)(*param_2 + iVar3 * 4); 12 | iVar2 = *(int *)(iVar1 + 8); 13 | if (*(int *)(iVar1 + 0xc) != iVar2) { 14 | param_2[1] = iVar3; 15 | if (*(char *)(param_2 + 2) == '\x01') { 16 | FUN_00001872(iVar1,param_1); 17 | } 18 | else { 19 | *(undefined *)(*(int *)(iVar1 + 4) + iVar2) = param_1; 20 | *(int *)(iVar1 + 8) = iVar2 + 1; 21 | } 22 | return 0; 23 | } 24 | if (*(int *)(*param_2 + iVar3 * 4 + 4) == 0) break; 25 | iVar3 = iVar3 + 1; 26 | } 27 | param_2[1] = iVar3; 28 | return 0xffffffff; 29 | } 30 | 31 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000dd52@0000dd52.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000dd52(undefined *param_1) 3 | 4 | { 5 | int iVar1; 6 | undefined4 uVar2; 7 | 8 | *param_1 = 0; 9 | iVar1 = FUN_0000d2ac(5,0,0,param_1,1); 10 | uVar2 = 0; 11 | if (iVar1 < 0) { 12 | uVar2 = 0xffffffff; 13 | } 14 | return uVar2; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000dd70@0000dd70.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_0000dd70(int param_1,int param_2) 3 | 4 | { 5 | undefined uVar1; 6 | int iVar2; 7 | 8 | iVar2 = 0; 9 | if (param_2 == 8) { 10 | *(undefined *)(param_1 + 0x248) = 0; 11 | } 12 | if (param_2 == 9) { 13 | uVar1 = 1; 14 | *(undefined *)(param_1 + 0x248) = 1; 15 | } 16 | else { 17 | uVar1 = *(undefined *)(param_1 + 0x248); 18 | } 19 | switch(uVar1) { 20 | case 0: 21 | break; 22 | case 1: 23 | FUN_0000c042(param_1); 24 | FUN_0000e552(param_1,0,param_1 + 8,8); 25 | *(undefined *)(param_1 + 0x248) = 2; 26 | break; 27 | case 2: 28 | if (param_2 == 10) { 29 | *(undefined *)(param_1 + 0x248) = 3; 30 | } 31 | break; 32 | case 3: 33 | case 4: 34 | if (param_2 != 0xd) { 35 | return 0; 36 | } 37 | if (*(int *)(param_1 + 0x24) == 8) { 38 | iVar2 = FUN_00004ec4(param_1,*(ushort **)(param_1 + 0x10)); 39 | return iVar2; 40 | } 41 | default: 42 | iVar2 = -1; 43 | } 44 | return iVar2; 45 | } 46 | 47 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000ddfa@0000ddfa.c: -------------------------------------------------------------------------------- 1 | 2 | char * FUN_0000ddfa(char *param_1,int param_2) 3 | 4 | { 5 | char *pcVar1; 6 | 7 | pcVar1 = FUN_00007d84(param_1,'\0',0x7fffffff); 8 | if (param_2 != 0) { 9 | pcVar1 = FUN_00007d84(param_1,(char)param_2,(int)pcVar1 - (int)param_1); 10 | } 11 | return pcVar1; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000df1c@0000df1c.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 * FUN_0000df1c(undefined4 *param_1,char *param_2) 3 | 4 | { 5 | char *pcVar1; 6 | 7 | pcVar1 = FUN_00007d84(param_2,'\0',0x7fffffff); 8 | FUN_00007dca(param_1,(undefined4 *)param_2,(uint)(pcVar1 + (1 - (int)param_2))); 9 | return param_1; 10 | } 11 | 12 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000df42@0000df42.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_0000df42(char *param_1) 3 | 4 | { 5 | char *pcVar1; 6 | 7 | pcVar1 = FUN_00007d84(param_1,'\0',0x7fffffff); 8 | return (int)pcVar1 - (int)param_1; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000df56@0000df56.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000df56(byte *param_1,byte *param_2,char *param_3) 3 | 4 | { 5 | char *pcVar1; 6 | 7 | pcVar1 = FUN_00007d84((char *)param_1,'\0',(int)param_3); 8 | if (pcVar1 != (char *)0x0) { 9 | param_3 = pcVar1 + (1 - (int)param_1); 10 | } 11 | FUN_00007d9e(param_1,param_2,(int)param_3); 12 | return; 13 | } 14 | 15 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000df7a@0000df7a.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 * FUN_0000df7a(undefined4 *param_1,char *param_2,char *param_3) 3 | 4 | { 5 | char *pcVar1; 6 | char *pcVar2; 7 | 8 | pcVar1 = FUN_00007d84(param_2,'\0',(int)param_3); 9 | pcVar2 = param_3; 10 | if (pcVar1 != (char *)0x0) { 11 | pcVar2 = pcVar1 + (1 - (int)param_2); 12 | } 13 | if (param_3 < pcVar2) { 14 | pcVar2 = param_3; 15 | } 16 | FUN_00007dca(param_1,(undefined4 *)param_2,(uint)pcVar2); 17 | if (pcVar2 < param_3) { 18 | FUN_00007e18((undefined4 *)((int)param_1 + (int)pcVar2),0,(int)param_3 - (int)pcVar2); 19 | } 20 | return param_1; 21 | } 22 | 23 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000dfbc@0000dfbc.c: -------------------------------------------------------------------------------- 1 | 2 | uint FUN_0000dfbc(byte *param_1,undefined4 *param_2,uint param_3) 3 | 4 | { 5 | uint uVar1; 6 | int *piVar2; 7 | int local_10; 8 | 9 | uVar1 = FUN_000007c6(param_1,param_2,param_3,&local_10); 10 | if (local_10 != 0) { 11 | piVar2 = (int *)FUN_00000680(); 12 | *piVar2 = local_10; 13 | } 14 | return uVar1; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000dfdc@0000dfdc.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000dfdc(char *param_1,uint param_2) 3 | 4 | { 5 | char cVar1; 6 | byte bVar2; 7 | char *pcVar3; 8 | int iVar4; 9 | 10 | iVar4 = 8; 11 | do { 12 | bVar2 = (byte)(param_2 >> 0x18); 13 | if (param_2 >> 0x1c < 10) { 14 | cVar1 = (bVar2 >> 4) + 0x30; 15 | } 16 | else { 17 | cVar1 = (bVar2 >> 4) + 0x57; 18 | } 19 | pcVar3 = param_1 + 1; 20 | *param_1 = cVar1; 21 | param_2 = param_2 << 4; 22 | param_1 = param_1 + 2; 23 | *pcVar3 = '\0'; 24 | iVar4 = iVar4 + -1; 25 | } while (0 < iVar4); 26 | return; 27 | } 28 | 29 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000e008@0000e008.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000e008(int param_1) 3 | 4 | { 5 | int iVar1; 6 | undefined4 uVar2; 7 | 8 | FUN_0000e598(param_1,0,(undefined4 *)(param_1 + 8),0); 9 | iVar1 = FUN_0000433c(param_1,0); 10 | uVar2 = 0xffffffff; 11 | if ((iVar1 << 0x19) >> 0x19 == 0xb) { 12 | uVar2 = 0; 13 | } 14 | return uVar2; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000e072@0000e072.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000e072(void) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | FUN_0000e21a(0xd); 8 | FUN_0000e21a(10); 9 | if (*(int *)(unaff_gp + 0x114) != 0) { 10 | FUN_0000af30(&LAB_0000e176,0,100000,10); 11 | } 12 | return; 13 | } 14 | 15 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000e09e@0000e09e.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_0000e09e(int param_1,undefined *param_2) 5 | 6 | { 7 | float fVar1; 8 | int iVar2; 9 | float fVar3; 10 | uint uVar4; 11 | int unaff_gp; 12 | 13 | if (*(int *)(unaff_gp + 0x114) == 0) { 14 | if (((int)param_2 < 0x2580) || (0xe1000 < (int)param_2)) { 15 | param_2 = &DAT_0001c200; 16 | } 17 | iVar2 = FUN_0000b8a2(); 18 | (**(code **)(iVar2 + 0x24))(0x3f5,0x3f6,0x100,*(code **)(iVar2 + 0x24)); 19 | (**(code **)(param_1 + 0x2c))(0x3f5,0x3f6,2,*(code **)(param_1 + 0x2c)); 20 | FUN_0000bf1c(1000); 21 | _DAT_7d001030 = 0; 22 | FUN_0000e260(); 23 | fVar3 = (float)FUN_0000b83c(); 24 | fVar1 = (float)fexp2(0xc0800000); 25 | uVar4 = FUN_0000b824((fVar3 * 1e+06) / ((float)(int)param_2 / fVar1),6); 26 | _DAT_7d001028 = uVar4 & 0x3f; 27 | _DAT_7d001024 = (int)uVar4 >> 6 & 0xffff; 28 | _DAT_7d00102c = 0x60; 29 | _DAT_7d001030 = _DAT_7d001030 | 0x100; 30 | FUN_0000e260(); 31 | *(undefined4 *)(unaff_gp + 0x114) = 1; 32 | _DAT_7d001030 = _DAT_7d001030 | 1; 33 | } 34 | return; 35 | } 36 | 37 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000e13e@0000e13e.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000e13e(void) 3 | 4 | { 5 | FUN_0000e21a(0xd); 6 | FUN_0000e21a(10); 7 | return; 8 | } 9 | 10 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000e21a@0000e21a.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_0000e21a(undefined4 param_1) 5 | 6 | { 7 | undefined4 uVar1; 8 | int iVar2; 9 | int unaff_gp; 10 | 11 | uVar1 = _DAT_7d001000; 12 | if (*(int *)(unaff_gp + 0x118) == 0) { 13 | if ((_DAT_7d001030 & 1) == 0) { 14 | iVar2 = *(int *)(unaff_gp + 0x114); 15 | } 16 | else { 17 | iVar2 = 1; 18 | *(undefined4 *)(unaff_gp + 0x114) = 1; 19 | } 20 | uVar1 = _DAT_7d001000; 21 | if ((iVar2 != 0) && (iVar2 = FUN_0000af30(&LAB_0000e188,0,2000,0), uVar1 = param_1, iVar2 != 0)) 22 | { 23 | FUN_0000e260(); 24 | uVar1 = param_1; 25 | } 26 | } 27 | _DAT_7d001000 = uVar1; 28 | return; 29 | } 30 | 31 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000e260@0000e260.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_0000e260(void) 5 | 6 | { 7 | _DAT_7d00102c = _DAT_7d00102c & 0xffffffef; 8 | FUN_0000af30(&LAB_0000e168,0,2000,0); 9 | _DAT_7d00102c = _DAT_7d00102c | 0x10; 10 | return; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000e28a@0000e28a.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_0000e28a(void) 5 | 6 | { 7 | undefined4 *puVar1; 8 | int iVar2; 9 | uint uVar3; 10 | uint uVar4; 11 | 12 | iVar2 = 0x1000; 13 | puVar1 = (undefined4 *)&DAT_7c481000; 14 | do { 15 | *puVar1 = 0; 16 | iVar2 = iVar2 + -4; 17 | puVar1 = puVar1 + 1; 18 | } while (0 < iVar2); 19 | uVar3 = _DAT_7c48004c >> 0x10; 20 | uVar4 = uVar3; 21 | while (uVar4 = uVar4 >> 1, uVar4 != 0) { 22 | uVar3 = uVar3 | uVar4; 23 | } 24 | iVar2 = uVar3 + 1; 25 | if (iVar2 != 0) { 26 | puVar1 = (undefined4 *)&DAT_7c4a0000; 27 | do { 28 | *puVar1 = 0; 29 | iVar2 = iVar2 + -1; 30 | puVar1 = puVar1 + 1; 31 | } while (iVar2 != 0); 32 | } 33 | return; 34 | } 35 | 36 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000e2c8@0000e2c8.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_0000e2c8(int param_1) 5 | 6 | { 7 | if (param_1 == 0) { 8 | _DAT_7c48000c = 0x20402700; 9 | FUN_0000bf1c(25000); 10 | _DAT_7c480400 = 1; 11 | _DAT_7c480404 = &USHORT_0000bb80; 12 | } 13 | else { 14 | _DAT_7c48000c = 0x40402700; 15 | _DAT_7c480b00 = 0x8000000; 16 | _DAT_7c480900 = 0x8000000; 17 | } 18 | FUN_0000e48c(); 19 | return; 20 | } 21 | 22 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000e320@0000e320.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Removing unreachable block (ram,0x0000e364) */ 3 | /* WARNING: Removing unreachable block (ram,0x0000e368) */ 4 | /* WARNING: Removing unreachable block (ram,0x0000e358) */ 5 | /* WARNING: Removing unreachable block (ram,0x0000e35e) */ 6 | /* WARNING: Removing unreachable block (ram,0x0000e36e) */ 7 | /* WARNING: Removing unreachable block (ram,0x0000e386) */ 8 | /* WARNING: Removing unreachable block (ram,0x0000e390) */ 9 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 10 | 11 | void FUN_0000e320(int param_1) 12 | 13 | { 14 | _DAT_7c480088 = _DAT_7c480088 | 0x30000; 15 | _DAT_7c480010 = 1; 16 | FUN_0000e48c(); 17 | do { 18 | } while ((_DAT_7c480010 & 1) != 0); 19 | do { 20 | } while( true ); 21 | } 22 | 23 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000e396@0000e396.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_0000e396(int param_1,char *param_2) 3 | 4 | { 5 | int iVar1; 6 | uint uStack_18; 7 | 8 | *(undefined4 *)(param_1 + 0x37c) = 0; 9 | do { 10 | FUN_0000df7a((undefined4 *)(param_1 + 0x27c),param_2,""); 11 | *(undefined *)(param_1 + 0x37b) = 0; 12 | *(undefined *)(param_1 + 0x380) = 0; 13 | iVar1 = FUN_000019d4(param_1,&uStack_18); 14 | iVar1 = FUN_0000dd70(param_1,(iVar1 << 0x19) >> 0x19); 15 | if (iVar1 != 0) break; 16 | } while (*(char *)(param_1 + 0x249) != '\b'); 17 | *(undefined *)(param_1 + 0x249) = 4; 18 | iVar1 = *(int *)(param_1 + 0x37c); 19 | if (iVar1 == 0) { 20 | iVar1 = -1; 21 | } 22 | return iVar1; 23 | } 24 | 25 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000e3f0@0000e3f0.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_0000e3f0(int param_1,int param_2,uint param_3) 3 | 4 | { 5 | uint uVar1; 6 | int iVar2; 7 | uint uStack_1c; 8 | 9 | uVar1 = *(uint *)(param_1 + 0x37c); 10 | if (uVar1 <= param_3) { 11 | param_3 = uVar1; 12 | } 13 | *(uint *)(param_1 + 0x37c) = uVar1 - param_3; 14 | if (param_3 == 0) { 15 | iVar2 = 0; 16 | } 17 | else { 18 | do { 19 | *(undefined *)(param_1 + 0x380) = 1; 20 | iVar2 = FUN_000019d4(param_1,&uStack_1c); 21 | iVar2 = FUN_0000dd70(param_1,(iVar2 << 0x19) >> 0x19); 22 | if (iVar2 != 0) break; 23 | } while (*(char *)(param_1 + 0x249) != '\a'); 24 | iVar2 = FUN_00003680(param_1,*(int *)(param_1 + 0x24c),param_2,param_3); 25 | FUN_000019d4(param_1,&uStack_1c); 26 | *(undefined *)(param_1 + 0x249) = 4; 27 | } 28 | return iVar2; 29 | } 30 | 31 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000e460@0000e460.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_0000e460(undefined4 param_1,uint param_2,undefined4 param_3,undefined4 param_4, 5 | undefined4 param_5,undefined4 param_6) 6 | 7 | { 8 | _write_to_stdout((byte *)s_USB_OTG_disconnect_0000e478,param_2,param_3,param_4,param_5,param_6); 9 | _DAT_7c480804 = _DAT_7c480804 | 2; 10 | return; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000e48c@0000e48c.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000e48c(void) 3 | 4 | { 5 | return; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000e53e@0000e53e.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000e53e(void) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | FUN_00007dca((undefined4 *)0xc0100000,(undefined4 *)(unaff_gp + 0x4f48),900); 8 | return; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000e552@0000e552.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ 3 | 4 | void FUN_0000e552(int param_1,int param_2,undefined4 param_3,uint param_4) 5 | 6 | { 7 | *(undefined4 *)(param_1 + param_2 * 4 + 0x10) = param_3; 8 | if (param_2 == 0) { 9 | _DAT_7c480b10 = (param_4 & 0x7f) + 0x20080000; 10 | _DAT_7c480b00 = 0x84008000; 11 | } 12 | else { 13 | *(uint *)(&DAT_7c480b10 + param_2 * 0x20) = (param_4 & 0x7f) + 0x80000; 14 | *(uint *)(&DAT_7c480b00 + param_2 * 0x20) = param_4 & 0x3ff | 0x84088000; 15 | } 16 | return; 17 | } 18 | 19 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000e598@0000e598.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000e598(int param_1,int param_2,undefined4 *param_3,int param_4) 3 | 4 | { 5 | int iVar1; 6 | int iVar2; 7 | int iVar3; 8 | int unaff_gp; 9 | 10 | iVar3 = param_2 * 0x20; 11 | if (param_2 == 0) { 12 | *(int *)(iVar3 + 0x7c480910) = param_4 + 0x80000; 13 | *(uint *)(&DAT_7c480900 + iVar3) = 0x84008000; 14 | } 15 | else { 16 | iVar1 = param_1 + param_2; 17 | *(int *)(iVar3 + 0x7c480910) = 18 | ((int)(((uint)(param_4 + 0x1ff >> 8) >> 0x17) + param_4 + 0x1ff) >> 9) * 0x80000 + param_4; 19 | iVar2 = 0x1d; 20 | if (*(char *)(iVar1 + 0x38) == '\0') { 21 | iVar2 = 0x1c; 22 | } 23 | *(uint *)(&DAT_7c480900 + iVar3) = 1 << iVar2 | 0x84000000U | param_2 << 0x16 | 0x88200; 24 | *(bool *)(iVar1 + 0x38) = *(char *)(iVar1 + 0x38) == '\0'; 25 | } 26 | for (iVar3 = (int)(((uint)(param_4 + 3 >> 1) >> 0x1e) + param_4 + 3) >> 2; 0 < iVar3; 27 | iVar3 = iVar3 + -1) { 28 | *(undefined4 *)(&DAT_7c481000 + param_2 * 0x1000) = *param_3; 29 | param_3 = param_3 + 1; 30 | } 31 | *(uint *)(unaff_gp + 0x7c) = *(uint *)(unaff_gp + 0x7c) | 1 << param_2; 32 | return; 33 | } 34 | 35 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000e642@0000e642.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0000e642(byte *param_1) 3 | 4 | { 5 | byte bVar1; 6 | 7 | if (param_1 != (byte *)0x0) { 8 | do { 9 | param_1 = param_1 + 1; 10 | bVar1 = *param_1; 11 | if (bVar1 == 0) { 12 | return 1; 13 | } 14 | if ((0x40 < bVar1) && (bVar1 < 0x5b)) { 15 | bVar1 = bVar1 + 0x20; 16 | } 17 | } while ((((0x60 < bVar1) && (bVar1 < 0x7b)) || ((0x2f < bVar1 && (bVar1 < 0x3a)))) || 18 | ((bVar1 == 0x2d || (bVar1 == 0x2e)))); 19 | } 20 | return 0; 21 | } 22 | 23 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000e682@0000e682.c: -------------------------------------------------------------------------------- 1 | 2 | int FUN_0000e682(void) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | return unaff_gp + 0x1d9c; 8 | } 9 | 10 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000e788@0000e788.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0000e788(void) 3 | 4 | { 5 | int unaff_gp; 6 | 7 | FUN_0000070e((uint *)(unaff_gp + 0x15c)); 8 | FUN_000006d6(); 9 | return; 10 | } 11 | 12 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0000f6fa@0000f6fa.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Control flow encountered unimplemented instructions */ 3 | 4 | void FUN_0000f6fa(void) 5 | 6 | { 7 | code *pcVar1; 8 | 9 | pcVar1 = (code *)swi(0xe); 10 | (*pcVar1)(); 11 | pcVar1 = (code *)swi(0xe); 12 | (*pcVar1)(); 13 | pcVar1 = (code *)swi(0xe); 14 | (*pcVar1)(); 15 | pcVar1 = (code *)swi(0xe); 16 | (*pcVar1)(); 17 | /* WARNING: Unimplemented instruction - Truncating control flow here */ 18 | halt_unimplemented(); 19 | } 20 | 21 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0001e8f2@0001e8f2.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Control flow encountered unimplemented instructions */ 3 | 4 | void FUN_0001e8f2(void) 5 | 6 | { 7 | /* WARNING: Unimplemented instruction - Truncating control flow here */ 8 | halt_unimplemented(); 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00020aec@00020aec.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Control flow encountered bad instruction data */ 3 | 4 | void FUN_00020aec(void) 5 | 6 | { 7 | /* WARNING: Bad instruction - Truncating control flow here */ 8 | halt_baddata(); 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_000287f2@000287f2.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Control flow encountered unimplemented instructions */ 3 | /* WARNING: Control flow encountered bad instruction data */ 4 | 5 | void FUN_000287f2(undefined4 param_1,undefined4 param_2,undefined *param_3,undefined4 param_4, 6 | undefined4 param_5) 7 | 8 | { 9 | undefined4 uVar1; 10 | undefined4 *unaff_r9; 11 | bool in_Z; 12 | bool in_C; 13 | bool in_V; 14 | 15 | unaff_r9[2] = param_5; 16 | if (in_C || in_Z) { 17 | version(); 18 | /* WARNING: Bad instruction - Truncating control flow here */ 19 | halt_baddata(); 20 | } 21 | if (in_V) { 22 | uVar1 = (*(code *)param_3)(); 23 | *unaff_r9 = uVar1; 24 | if (!in_C) { 25 | /* WARNING: Unimplemented instruction - Truncating control flow here */ 26 | halt_unimplemented(); 27 | } 28 | /* WARNING: Bad instruction - Truncating control flow here */ 29 | halt_baddata(); 30 | } 31 | /* WARNING: Bad instruction - Truncating control flow here */ 32 | halt_baddata(); 33 | } 34 | 35 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0002e5b8@0002e5b8.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Control flow encountered bad instruction data */ 3 | 4 | void FUN_0002e5b8(void) 5 | 6 | { 7 | /* WARNING: Bad instruction - Truncating control flow here */ 8 | halt_baddata(); 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0002f3fe@0002f3fe.c: -------------------------------------------------------------------------------- 1 | 2 | void FUN_0002f3fe(void) 3 | 4 | { 5 | code *UNRECOVERED_JUMPTABLE; 6 | 7 | /* WARNING: Could not recover jumptable at 0x0002f400. Too many branches */ 8 | /* WARNING: Treating indirect jump as call */ 9 | (*UNRECOVERED_JUMPTABLE)(); 10 | return; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0003a670@0003a670.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Control flow encountered bad instruction data */ 3 | 4 | void FUN_0003a670(void) 5 | 6 | { 7 | /* WARNING: Bad instruction - Truncating control flow here */ 8 | halt_baddata(); 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0005ace2@0005ace2.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Control flow encountered bad instruction data */ 3 | 4 | void FUN_0005ace2(void) 5 | 6 | { 7 | /* WARNING: Bad instruction - Truncating control flow here */ 8 | halt_baddata(); 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0005b4f0@0005b4f0.c: -------------------------------------------------------------------------------- 1 | 2 | undefined8 FUN_0005b4f0(int param_1) 3 | 4 | { 5 | undefined4 unaff_r6; 6 | undefined4 in_stack_00000000; 7 | undefined4 in_stack_00000004; 8 | 9 | *(undefined4 *)(param_1 + 0x10) = unaff_r6; 10 | return CONCAT44(in_stack_00000000,in_stack_00000004); 11 | } 12 | 13 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0005e850@0005e850.c: -------------------------------------------------------------------------------- 1 | 2 | undefined4 FUN_0005e850(void) 3 | 4 | { 5 | undefined4 in_stack_0000000c; 6 | 7 | return in_stack_0000000c; 8 | } 9 | 10 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00075514@00075514.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Control flow encountered bad instruction data */ 3 | 4 | void FUN_00075514(void) 5 | 6 | { 7 | /* WARNING: Bad instruction - Truncating control flow here */ 8 | halt_baddata(); 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_0007ee62@0007ee62.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Control flow encountered bad instruction data */ 3 | 4 | void FUN_0007ee62(void) 5 | 6 | { 7 | /* WARNING: Bad instruction - Truncating control flow here */ 8 | halt_baddata(); 9 | } 10 | 11 | -------------------------------------------------------------------------------- /haruspex-output/FUN_00090aec@00090aec.c: -------------------------------------------------------------------------------- 1 | 2 | /* WARNING: Control flow encountered bad instruction data */ 3 | 4 | void FUN_00090aec(undefined4 param_1,int param_2,undefined4 param_3) 5 | 6 | { 7 | DAT_0008ea3a = param_3; 8 | *(undefined4 *)(param_2 + 0x10) = param_3; 9 | /* WARNING: Bad instruction - Truncating control flow here */ 10 | halt_baddata(); 11 | } 12 | 13 | -------------------------------------------------------------------------------- /haruspex-output/caseD_48@0000bdfe.c: -------------------------------------------------------------------------------- 1 | 2 | void switchD_0000bb70::caseD_48(void) 3 | 4 | { 5 | int unaff_r7; 6 | code *unaff_r10; 7 | undefined4 *unaff_r11; 8 | byte *pbVar1; 9 | 10 | pbVar1 = (byte *)*unaff_r11; 11 | if (unaff_r7 < 1) { 12 | FUN_0000bae2(); 13 | return; 14 | } 15 | do { 16 | FUN_000098ec((int)(uint)*pbVar1 >> 4); 17 | (*unaff_r10)(); 18 | FUN_000098ec(*pbVar1 & 0xf); 19 | (*unaff_r10)(); 20 | unaff_r7 = unaff_r7 + -1; 21 | pbVar1 = pbVar1 + 1; 22 | } while (0 < unaff_r7); 23 | FUN_0000bae2(); 24 | return; 25 | } 26 | 27 | --------------------------------------------------------------------------------