diff --git a/DumpList.java b/DumpList.java new file mode 100644 index 0000000..360c89a --- /dev/null +++ b/DumpList.java @@ -0,0 +1,75 @@ +import ghidra.app.script.GhidraScript; +import ghidra.app.decompiler.DecompInterface; +import ghidra.app.decompiler.DecompileResults; +import ghidra.program.model.listing.Function; +import ghidra.program.model.listing.FunctionManager; +import ghidra.program.model.listing.Instruction; +import ghidra.program.model.address.Address; +import ghidra.program.model.address.AddressSpace; +import java.io.PrintWriter; +import java.io.BufferedReader; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.BufferedWriter; +import java.util.*; + +/** + * Decompile a specific list of addresses given in the FIRST line of a file + * (comma-separated hex). Includes tiny functions. Writes C into an output file. + */ +public class DumpList extends GhidraScript { + + @Override + public void run() throws Exception { + long LO = 0x180000000L; + long HI = 0x182c00000L; + String listFile = System.getProperty("DumpList.list", + "/home/m/re-tools/focus_list.txt"); + String outFile = System.getProperty("DumpList.out", + "/home/m/re-tools/focus_decomp.txt"); + + Set targets = new LinkedHashSet<>(); + BufferedReader br = new BufferedReader(new FileReader(listFile)); + String line; + while ((line = br.readLine()) != null) { + line = line.trim(); + if (line.isEmpty()) continue; + for (String tok : line.split(",")) { + tok = tok.trim(); + if (tok.isEmpty()) continue; + try { + targets.add(Long.parseLong(tok.replaceFirst("^0x", ""), 16)); + } catch (Exception e) { println("bad tok " + tok); } + } + } + br.close(); + + FunctionManager fm = currentProgram.getFunctionManager(); + AddressSpace as = currentProgram.getAddressFactory().getDefaultAddressSpace(); + DecompInterface di = new DecompInterface(); + di.openProgram(currentProgram); + + PrintWriter pw = new PrintWriter(new java.io.BufferedWriter( + new FileWriter(outFile, false))); + for (long a : targets) { + if (a < LO || a > HI) continue; + Function f = fm.getFunctionAt(as.getAddress(a)); + if (f == null) { + pw.println("############ NO_FUNCTION 0x" + Long.toHexString(a) + " ############"); + continue; + } + DecompileResults res = di.decompileFunction(f, 120, monitor); + pw.println("############ FUN_ " + Long.toHexString(a) + " size=" + + f.getBody().getNumAddresses() + " ############"); + if (res != null && res.getDecompiledFunction() != null) { + pw.println(res.getDecompiledFunction().getC()); + } else { + pw.println("// decompile failed"); + } + pw.println(); + } + pw.close(); + di.dispose(); + println("DUMPLIST_DONE n=" + targets.size()); + } +} \ No newline at end of file diff --git a/SearchRefs.java b/SearchRefs.java new file mode 100644 index 0000000..208ac2b --- /dev/null +++ b/SearchRefs.java @@ -0,0 +1,30 @@ +import ghidra.app.script.GhidraScript; +import ghidra.program.model.symbol.Reference; +import ghidra.program.model.symbol.ReferenceIterator; +import ghidra.program.model.address.Address; +import ghidra.program.model.address.AddressSpace; +import java.io.PrintWriter; + +public class SearchRefs extends GhidraScript { + @Override + public void run() throws Exception { + String[] targets = {"180008140","180039aa0","181c5cd10","18003f1a0","18003f600"}; + AddressSpace as = currentProgram.getAddressFactory().getDefaultAddressSpace(); + PrintWriter pw = new PrintWriter(new java.io.BufferedWriter( + new java.io.FileWriter("/home/m/re-tools/xrefs.txt"))); + for (String ts : targets) { + long ta = Long.parseLong(ts,16); + Address t = as.getAddress(ta); + pw.println("### TARGET " + ts); + ReferenceIterator it = currentProgram.getReferenceManager().getReferencesTo(t); + int n=0; + while (it.hasNext() && n<200) { + Reference r = it.next(); + pw.println(" from " + r.getFromAddress() + " type=" + r.getReferenceType()); + n++; + } + } + pw.close(); + println("XREFS_DONE"); + } +} diff --git a/dispatch_targets.txt b/dispatch_targets.txt new file mode 100644 index 0000000..a18d904 --- /dev/null +++ b/dispatch_targets.txt @@ -0,0 +1 @@ +0x180001c30,0x180001c60,0x180001c90,0x180001cc0,0x180001cf0,0x180001d20,0x180001d50,0x180001d80,0x180001db0,0x180001de0,0x180001e10,0x180001e40,0x180001e70,0x180001ea0,0x180001ed0,0x180001f00,0x180001f30,0x180001f60,0x180001f90,0x180001fc0,0x180001ff0,0x180002020,0x180002050,0x180002080,0x1800020b0,0x1800020e0,0x180002110,0x180002140,0x180002170,0x1800021a0,0x1800021d0,0x180002200,0x180002230,0x180002260,0x180002290,0x1800022c0,0x1800058a0,0x1800058e0,0x180005920,0x180005960,0x180005a20,0x180005ae0,0x180008140,0x180008440,0x180008480,0x1800084c0,0x180008500,0x180008700,0x1800088c0,0x180008a80,0x180008ac0,0x180008b00,0x180008b40,0x180008d60,0x180008f40,0x180009120,0x180009160,0x1800091a0,0x1800091e0,0x180009380,0x1800094a0,0x1800095c0,0x180009600,0x180009640,0x180009680,0x1800096c0,0x180009700,0x180009740,0x180009780,0x1800097e0,0x180009820,0x180009860,0x1800098a0,0x1800098e0,0x180009940,0x1800099a0,0x180009a00,0x180009be0,0x180009dc0,0x180009fa0,0x18000a160,0x18000a340,0x18000a500,0x18000a6c0,0x18000a880,0x18000aa40,0x18000aa80,0x18000aac0,0x18000ab00,0x18000ad60,0x18000af00,0x18000b0c0,0x18000b100,0x18000b140,0x18000b180,0x18000b3c0,0x18000b560,0x18000b700,0x18000b740,0x18000b7a0,0x18000b7e0,0x18000b820,0x18000b860,0x18000b8a0,0x18000b8e0,0x18000b920,0x18000b960,0x18000bba0,0x18000bda0,0x18000bfc0,0x18000c1c0,0x18000c3e0,0x18000c5e0,0x18000c7e0,0x18000c9e0,0x18000cbe0,0x18000cc20,0x18000cc60,0x18000cca0,0x18000cdc0,0x18000cf80,0x18000d140,0x18000d320,0x18000d4e0,0x18000d6a0,0x18000d880,0x18000da60,0x18000daa0,0x18000dae0,0x18000db20,0x18000dc40,0x18000de00,0x18000de40,0x18000dea0,0x18000dee0,0x18000df20,0x18000df60,0x18000dfa0,0x18000dfe0,0x18000e020,0x18000e060,0x18000e360,0x18000e560,0x18000e780,0x18000e9a0,0x18000ebc0,0x18000ede0,0x18000ee20,0x18000ee60,0x18000eea0,0x18000f0a0,0x18000f240,0x18000f440,0x18000f620,0x18000f720,0x18000f8e0,0x18000f920,0x18000f960,0x18000f9a0,0x18000fb60,0x18000fd00,0x18000fd60,0x18000fdc0,0x18000fe20,0x18000ffe0,0x1800101a0,0x180010360,0x1800103e0,0x180010460,0x1800104e0,0x180010860,0x180010bc0,0x180010c00,0x180010c40,0x180010c80,0x180010e40,0x180010fe0,0x180011260,0x1800112a0,0x1800112e0,0x180011320,0x180011360,0x1800113a0,0x1800113e0,0x180011420,0x180011460,0x180011580,0x180011740,0x1800117c0,0x180011840,0x1800118c0,0x180011940,0x1800119c0,0x180011a40,0x180011c60,0x180011e80,0x180012100,0x180012320,0x180012420,0x180012560,0x180012580,0x1800125a0,0x1800125c0,0x1800125e0,0x180012600,0x180012620,0x180012660,0x1800126a0,0x1800126e0,0x1800128e0,0x180012aa0,0x180012c60,0x180012ca0,0x180012ce0,0x180012ee0,0x1800130e0,0x1800132e0,0x1800134e0,0x180013560,0x1800135e0,0x180013660,0x1800136e0,0x180013760,0x1800137e0,0x180013ae0,0x180013de0,0x1800140e0,0x1800143e0,0x1800146e0,0x1800149e0,0x180014a20,0x180014a60,0x180014aa0,0x180014c40,0x180014dc0,0x180014e00,0x180014e60,0x180014ea0,0x180015060,0x180015200,0x180015240,0x180015280,0x1800152c0,0x180015300,0x180015340 \ No newline at end of file diff --git a/focus_decomp.txt b/focus_decomp.txt new file mode 100644 index 0000000..21bfb99 --- /dev/null +++ b/focus_decomp.txt @@ -0,0 +1,894 @@ +############ NO_FUNCTION 0x18001474c ############ +############ FUN_ 18003b6c0 size=559 ############ + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +longlong FUN_18003b6c0(longlong param_1,uint param_2,longlong param_3,int param_4,undefined8 param_5 + ,undefined8 param_6) + +{ + longlong lVar1; + undefined8 uVar2; + longlong lVar3; + ulonglong uVar4; + uint uVar5; + longlong lVar6; + uint uVar7; + uint uVar8; + int iVar9; + int iVar10; + longlong lVar11; + longlong lVar12; + int iVar13; + longlong lVar14; + longlong lVar15; + + if ((int)param_2 < 0x12) { + uVar2 = FUN_180034280(param_2,param_5); + } + else { + uVar2 = FUN_180105de0(param_2,5,param_5); + } + if (*(int *)(&DAT_181c5e3fc + (longlong)(int)param_2 * 4) == 0) { + *(undefined8 *)(param_1 + 0x38) = uVar2; + lVar3 = FUN_18003a2a0(0x11,param_3,param_4); + iVar10 = 1; + iVar9 = 1 << (param_2 & 0x1f); + uVar5 = (int)(((uint)(iVar9 >> 1) >> 0x1e) + iVar9) >> 2; + *(longlong *)(param_1 + 0x40) = lVar3; + if (0 < (int)uVar5) { + if (uVar5 >> 1 != 0) { + iVar10 = 1 << (param_4 - param_2 & 0x1f); + iVar9 = uVar5 * iVar10 + iVar10; + lVar15 = (longlong)iVar10; + lVar14 = 0; + lVar12 = (longlong)(iVar9 + iVar10 * -2); + lVar11 = (longlong)(iVar9 - iVar10); + uVar8 = 0; + do { + uVar7 = uVar8; + lVar1 = lVar11 * 8; + uVar8 = uVar7 + 1; + lVar6 = (longlong)(int)(uVar7 * 2) * 0x10; + lVar11 = lVar11 + iVar10 * -2; + *(undefined8 *)(lVar3 + lVar6) = *(undefined8 *)(param_3 + lVar1); + lVar1 = lVar14 * 8; + lVar14 = lVar14 + iVar10 * 2; + *(ulonglong *)(lVar3 + 8 + lVar6) = *(ulonglong *)(param_3 + lVar1) ^ _DAT_181c5e4e0; + lVar1 = lVar12 * 8; + lVar12 = lVar12 + iVar10 * -2; + *(undefined8 *)(lVar3 + 0x10 + lVar6) = *(undefined8 *)(param_3 + lVar1); + lVar1 = lVar15 * 8; + lVar15 = lVar15 + iVar10 * 2; + *(ulonglong *)(lVar3 + 0x18 + lVar6) = *(ulonglong *)(param_3 + lVar1) ^ _DAT_181c5e4e0; + } while (uVar8 < uVar5 >> 1); + iVar10 = uVar7 + 2 + uVar8; + } + if (iVar10 - 1U < uVar5) { + iVar9 = 1 << (param_4 - param_2 & 0x1f); + iVar13 = (iVar10 - 1U) * iVar9; + *(undefined8 *)((longlong)iVar10 * 0x10 + -0x10 + lVar3) = + *(undefined8 *)(param_3 + (longlong)(int)(iVar9 * uVar5 - iVar13) * 8); + *(ulonglong *)((longlong)iVar10 * 0x10 + -8 + lVar3) = + *(ulonglong *)(param_3 + (longlong)iVar13 * 8) ^ _DAT_181c5e4e0; + } + } + uVar4 = lVar3 + (longlong)(int)uVar5 * 0x10; + *(undefined4 *)(param_1 + 0x1c) = 0x200000; + lVar3 = uVar4 + (-(uVar4 & 0x3f) & 0x3f); + } + else { + lVar3 = FUN_18003b900(param_1,param_2,param_3,param_4,0,uVar2,param_6); + } + if (0x11 < (int)param_2) { + iVar10 = 0x8000; + if (0x7fff < *(int *)(param_1 + 0x1c)) { + iVar10 = *(int *)(param_1 + 0x1c); + } + *(int *)(param_1 + 0x1c) = iVar10; + } + return lVar3; +} + + + +############ FUN_ 18003f1a0 size=1102 ############ + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +longlong FUN_18003f1a0(uint param_1,longlong param_2,int param_3,longlong param_4) + +{ + longlong lVar1; + double dVar2; + int iVar3; + ulonglong uVar4; + longlong lVar5; + longlong lVar6; + longlong lVar7; + uint uVar8; + int iVar9; + longlong lVar10; + longlong lVar11; + longlong lVar12; + int iVar13; + uint uVar14; + uint uVar15; + longlong lVar16; + int iVar17; + uint uVar18; + ulonglong uVar19; + longlong lVar20; + undefined1 auVar21 [16]; + undefined1 auVar22 [16]; + undefined1 auVar23 [16]; + undefined1 auVar24 [16]; + undefined1 auVar25 [16]; + undefined1 auVar26 [16]; + undefined1 auVar27 [16]; + undefined1 auVar28 [16]; + + dVar2 = DAT_181c5e510; + iVar13 = 1; + iVar9 = 1 << (param_1 & 0x1f); + iVar17 = 1 << (param_3 - param_1 & 0x1f); + iVar3 = ((uint)(iVar9 >> 1) >> 0x1e) + iVar9; + lVar6 = (longlong)(iVar17 * 2); + uVar18 = iVar3 >> 2; + uVar19 = (ulonglong)uVar18; + lVar7 = (longlong)(iVar17 * -2); + if (iVar9 < 0x20000) { + uVar19 = (ulonglong)(int)uVar18; + uVar4 = 2; + if (8 < iVar9) { + uVar4 = uVar19; + } + } + else { + uVar4 = (longlong)(iVar3 >> 0xb) + 0x200; + } + uVar4 = uVar4 * 0x10 + param_4; + lVar5 = uVar4 + (-(uVar4 & 0x3f) & 0x3f); + uVar18 = (uint)uVar19; + if (iVar9 < 0x20000) { + if (iVar9 < 9) { + if (0 < (int)uVar18) { + if ((uVar19 >> 1 & 0x7fffffff) != 0) { + auVar21._8_8_ = 0; + auVar21._0_8_ = DAT_181c5e510; + iVar13 = uVar18 * iVar17 + iVar17; + lVar7 = (longlong)iVar17; + lVar11 = 0; + lVar6 = (longlong)(iVar13 + iVar17 * -2); + lVar16 = (longlong)(iVar13 - iVar17); + uVar8 = 0; + do { + uVar15 = uVar8; + lVar10 = lVar16 * 8; + lVar20 = (longlong)(int)(uVar15 * 4); + uVar8 = uVar15 + 1; + lVar16 = lVar16 + iVar17 * -2; + *(double *)(param_4 + lVar20 * 8) = dVar2 * *(double *)(param_2 + lVar10); + auVar24._8_8_ = 0; + auVar24._0_8_ = *(ulonglong *)(param_2 + lVar11 * 8); + lVar11 = lVar11 + iVar17 * 2; + auVar24 = vfnmadd213sd_fma(auVar24,auVar21,auVar21); + *(longlong *)(param_4 + 8 + lVar20 * 8) = auVar24._0_8_; + lVar10 = lVar6 * 8; + lVar6 = lVar6 + iVar17 * -2; + *(double *)(param_4 + 0x10 + lVar20 * 8) = dVar2 * *(double *)(param_2 + lVar10); + auVar27._8_8_ = 0; + auVar27._0_8_ = *(ulonglong *)(param_2 + lVar7 * 8); + lVar7 = lVar7 + iVar17 * 2; + auVar24 = vfnmadd213sd_fma(auVar27,auVar21,auVar21); + *(longlong *)(param_4 + 0x18 + lVar20 * 8) = auVar24._0_8_; + } while (uVar8 < ((uint)(uVar19 >> 1) & 0x7fffffff)); + iVar13 = uVar15 + 2 + uVar8; + } + if (iVar13 - 1U < uVar18) { + iVar3 = (iVar13 - 1U) * iVar17; + auVar25._8_8_ = 0; + auVar25._0_8_ = DAT_181c5e510; + *(double *)(param_4 + -0x10 + (longlong)(iVar13 * 2) * 8) = + DAT_181c5e510 * *(double *)(param_2 + (longlong)(int)(uVar18 * iVar17 - iVar3) * 8); + auVar23._8_8_ = 0; + auVar23._0_8_ = *(ulonglong *)(param_2 + (longlong)iVar3 * 8); + auVar21 = vfnmadd213sd_fma(auVar25,auVar23,auVar25); + *(longlong *)(param_4 + -8 + (longlong)(iVar13 * 2) * 8) = auVar21._0_8_; + } + } + return lVar5; + } + lVar11 = (longlong)iVar17; + iVar13 = 0; + if (0 < (int)uVar18) { + auVar22._8_8_ = 0; + auVar22._0_8_ = DAT_181c5e510; + lVar10 = (longlong)(int)(iVar17 * uVar18 - iVar17); + lVar20 = (longlong)(iVar17 * 2); + lVar16 = (longlong)(int)(iVar17 * uVar18 + iVar17 * -2); + do { + lVar1 = lVar10 * 8; + lVar12 = (longlong)(iVar13 * 2); + iVar13 = iVar13 + 2; + lVar10 = lVar10 + lVar7; + *(double *)(param_4 + lVar12 * 8) = dVar2 * *(double *)(param_2 + lVar1); + lVar1 = lVar16 * 8; + lVar16 = lVar16 + lVar7; + *(double *)(param_4 + 8 + lVar12 * 8) = dVar2 * *(double *)(param_2 + lVar1); + auVar26._8_8_ = 0; + auVar26._0_8_ = *(ulonglong *)(param_2 + lVar11 * 8); + lVar11 = lVar11 + lVar6; + auVar21 = vfnmadd213sd_fma(auVar26,auVar22,auVar22); + *(longlong *)(param_4 + 0x10 + lVar12 * 8) = auVar21._0_8_; + auVar28._8_8_ = 0; + auVar28._0_8_ = *(ulonglong *)(param_2 + lVar20 * 8); + lVar20 = lVar20 + lVar6; + auVar21 = vfnmadd213sd_fma(auVar28,auVar22,auVar22); + *(longlong *)(param_4 + 0x18 + lVar12 * 8) = auVar21._0_8_; + } while (iVar13 < (int)uVar18); + } + } + else { + iVar3 = 0; + lVar10 = (longlong)(int)(iVar17 * uVar18 - iVar17); + lVar20 = (longlong)(iVar17 * 2); + lVar16 = (longlong)(int)(iVar17 * uVar18 + iVar17 * -2); + lVar11 = (longlong)iVar17; + do { + uVar19 = (ulonglong)(uint)(iVar3 * 2); + *(undefined8 *)(param_4 + uVar19 * 8) = *(undefined8 *)(param_2 + lVar10 * 8); + iVar3 = iVar3 + 2; + lVar10 = lVar10 + lVar7; + *(undefined8 *)(param_4 + 8 + uVar19 * 8) = *(undefined8 *)(param_2 + lVar16 * 8); + lVar16 = lVar16 + lVar7; + lVar1 = lVar11 * 8; + lVar11 = lVar11 + lVar6; + *(ulonglong *)(param_4 + 0x10 + uVar19 * 8) = *(ulonglong *)(param_2 + lVar1) ^ _DAT_181c5e500 + ; + lVar1 = lVar20 * 8; + lVar20 = lVar20 + lVar6; + *(ulonglong *)(param_4 + 0x18 + uVar19 * 8) = *(ulonglong *)(param_2 + lVar1) ^ _DAT_181c5e500 + ; + } while (iVar3 < 0x200); + if (0 < (int)uVar18) { + uVar8 = uVar18 + 0x1ff; + if (uVar8 >> 10 != 0) { + iVar3 = iVar17 * -0x400; + lVar6 = (longlong)(iVar17 * 0x200); + iVar13 = uVar18 * iVar17 + iVar17 * 0x200; + lVar11 = 0; + lVar7 = (longlong)(iVar13 + iVar3); + lVar16 = (longlong)(iVar17 * -0x200 + iVar13); + uVar15 = 0; + do { + uVar14 = uVar15; + lVar10 = lVar16 * 8; + lVar20 = (longlong)(int)(uVar14 * 4); + uVar15 = uVar14 + 1; + lVar16 = lVar16 + iVar3; + *(undefined8 *)(param_4 + 0x2000 + lVar20 * 8) = *(undefined8 *)(param_2 + lVar10); + lVar10 = lVar11 * 8; + lVar11 = lVar11 + iVar17 * 0x400; + *(ulonglong *)(param_4 + 0x2008 + lVar20 * 8) = + *(ulonglong *)(param_2 + lVar10) ^ _DAT_181c5e500; + lVar10 = lVar7 * 8; + lVar7 = lVar7 + iVar3; + *(undefined8 *)(param_4 + 0x2010 + lVar20 * 8) = *(undefined8 *)(param_2 + lVar10); + lVar10 = lVar6 * 8; + lVar6 = lVar6 + iVar17 * 0x400; + *(ulonglong *)(param_4 + 0x2018 + lVar20 * 8) = + *(ulonglong *)(param_2 + lVar10) ^ _DAT_181c5e500; + } while (uVar15 < uVar8 >> 10); + iVar13 = uVar14 + 2 + uVar15; + } + uVar15 = iVar13 - 1; + if (uVar15 < (uint)((int)(((uint)((int)uVar8 >> 8) >> 0x17) + 0x1ff + uVar18) >> 9)) { + *(undefined8 *)(param_4 + 0x1ff0 + (longlong)(iVar13 * 2) * 8) = + *(undefined8 *) + (param_2 + (longlong)(int)(uVar18 * iVar17 + uVar15 * iVar17 * -0x200) * 8); + *(ulonglong *)(param_4 + 0x1ff8 + (longlong)(iVar13 * 2) * 8) = + *(ulonglong *)(param_2 + (longlong)(int)(iVar17 * 0x200 * uVar15) * 8) ^ _DAT_181c5e500 + ; + } + } + } + return lVar5; +} + + + +############ FUN_ 18003f600 size=1038 ############ + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +longlong FUN_18003f600(uint param_1,longlong param_2,int param_3,longlong param_4) + +{ + longlong lVar1; + int iVar2; + ulonglong uVar3; + longlong lVar4; + longlong lVar5; + longlong lVar6; + longlong lVar7; + int iVar8; + int iVar9; + uint uVar10; + longlong lVar11; + longlong lVar12; + longlong lVar13; + uint uVar14; + uint uVar15; + int iVar16; + uint uVar17; + ulonglong uVar18; + longlong lVar19; + + iVar8 = 1; + iVar9 = 1 << (param_1 & 0x1f); + iVar16 = 1 << (param_3 - param_1 & 0x1f); + iVar2 = ((uint)(iVar9 >> 1) >> 0x1e) + iVar9; + lVar5 = (longlong)(iVar16 * 2); + uVar17 = iVar2 >> 2; + uVar18 = (ulonglong)uVar17; + lVar6 = (longlong)(iVar16 * -2); + if (iVar9 < 0x20000) { + uVar18 = (ulonglong)(int)uVar17; + uVar3 = 2; + if (8 < iVar9) { + uVar3 = uVar18; + } + } + else { + uVar3 = (longlong)(iVar2 >> 0xb) + 0x200; + } + uVar3 = uVar3 * 0x10 + param_4; + lVar4 = uVar3 + (-(uVar3 & 0x3f) & 0x3f); + uVar17 = (uint)uVar18; + if (iVar9 < 0x20000) { + if (iVar9 < 9) { + if (0 < (int)uVar17) { + if ((uVar18 >> 1 & 0x7fffffff) != 0) { + iVar8 = uVar17 * iVar16 + iVar16; + lVar12 = (longlong)iVar16; + lVar19 = 0; + lVar6 = (longlong)(iVar8 + iVar16 * -2); + lVar5 = (longlong)(iVar8 - iVar16); + uVar10 = 0; + do { + uVar15 = uVar10; + lVar11 = lVar5 * 8; + lVar7 = (longlong)(int)(uVar15 * 4); + uVar10 = uVar15 + 1; + lVar5 = lVar5 + iVar16 * -2; + *(undefined8 *)(param_4 + lVar7 * 8) = *(undefined8 *)(param_2 + lVar11); + lVar11 = lVar19 * 8; + lVar19 = lVar19 + iVar16 * 2; + *(ulonglong *)(param_4 + 8 + lVar7 * 8) = + *(ulonglong *)(param_2 + lVar11) ^ _DAT_181c5e520; + lVar11 = lVar6 * 8; + lVar6 = lVar6 + iVar16 * -2; + *(undefined8 *)(param_4 + 0x10 + lVar7 * 8) = *(undefined8 *)(param_2 + lVar11); + lVar11 = lVar12 * 8; + lVar12 = lVar12 + iVar16 * 2; + *(ulonglong *)(param_4 + 0x18 + lVar7 * 8) = + *(ulonglong *)(param_2 + lVar11) ^ _DAT_181c5e520; + } while (uVar10 < ((uint)(uVar18 >> 1) & 0x7fffffff)); + iVar8 = uVar15 + 2 + uVar10; + } + if (iVar8 - 1U < uVar17) { + iVar2 = (iVar8 - 1U) * iVar16; + *(undefined8 *)(param_4 + -0x10 + (longlong)(iVar8 * 2) * 8) = + *(undefined8 *)(param_2 + (longlong)(int)(uVar17 * iVar16 - iVar2) * 8); + *(ulonglong *)(param_4 + -8 + (longlong)(iVar8 * 2) * 8) = + *(ulonglong *)(param_2 + (longlong)iVar2 * 8) ^ _DAT_181c5e520; + } + } + return lVar4; + } + lVar12 = (longlong)iVar16; + iVar8 = 0; + if (0 < (int)uVar17) { + lVar19 = (longlong)(int)(iVar16 * uVar17 - iVar16); + lVar7 = (longlong)(iVar16 * 2); + lVar11 = (longlong)(int)(iVar16 * uVar17 + iVar16 * -2); + do { + lVar1 = lVar19 * 8; + lVar13 = (longlong)(iVar8 * 2); + iVar8 = iVar8 + 2; + lVar19 = lVar19 + lVar6; + *(undefined8 *)(param_4 + lVar13 * 8) = *(undefined8 *)(param_2 + lVar1); + lVar1 = lVar11 * 8; + lVar11 = lVar11 + lVar6; + *(undefined8 *)(param_4 + 8 + lVar13 * 8) = *(undefined8 *)(param_2 + lVar1); + lVar1 = lVar12 * 8; + lVar12 = lVar12 + lVar5; + *(ulonglong *)(param_4 + 0x10 + lVar13 * 8) = + *(ulonglong *)(param_2 + lVar1) ^ _DAT_181c5e520; + lVar1 = lVar7 * 8; + lVar7 = lVar7 + lVar5; + *(ulonglong *)(param_4 + 0x18 + lVar13 * 8) = + *(ulonglong *)(param_2 + lVar1) ^ _DAT_181c5e520; + } while (iVar8 < (int)uVar17); + } + } + else { + iVar2 = 0; + lVar11 = (longlong)(int)(iVar16 * uVar17 - iVar16); + lVar7 = (longlong)(iVar16 * 2); + lVar19 = (longlong)(int)(iVar16 * uVar17 + iVar16 * -2); + lVar12 = (longlong)iVar16; + do { + uVar18 = (ulonglong)(uint)(iVar2 * 2); + *(undefined8 *)(param_4 + uVar18 * 8) = *(undefined8 *)(param_2 + lVar11 * 8); + iVar2 = iVar2 + 2; + lVar11 = lVar11 + lVar6; + *(undefined8 *)(param_4 + 8 + uVar18 * 8) = *(undefined8 *)(param_2 + lVar19 * 8); + lVar19 = lVar19 + lVar6; + lVar1 = lVar12 * 8; + lVar12 = lVar12 + lVar5; + *(ulonglong *)(param_4 + 0x10 + uVar18 * 8) = *(ulonglong *)(param_2 + lVar1) ^ _DAT_181c5e520 + ; + lVar1 = lVar7 * 8; + lVar7 = lVar7 + lVar5; + *(ulonglong *)(param_4 + 0x18 + uVar18 * 8) = *(ulonglong *)(param_2 + lVar1) ^ _DAT_181c5e520 + ; + } while (iVar2 < 0x200); + if (0 < (int)uVar17) { + uVar10 = uVar17 + 0x1ff; + if (uVar10 >> 10 != 0) { + iVar2 = iVar16 * -0x400; + lVar5 = (longlong)(iVar16 * 0x200); + iVar8 = uVar17 * iVar16 + iVar16 * 0x200; + lVar12 = 0; + lVar6 = (longlong)(iVar8 + iVar2); + lVar19 = (longlong)(iVar16 * -0x200 + iVar8); + uVar15 = 0; + do { + uVar14 = uVar15; + lVar11 = lVar19 * 8; + lVar7 = (longlong)(int)(uVar14 * 4); + uVar15 = uVar14 + 1; + lVar19 = lVar19 + iVar2; + *(undefined8 *)(param_4 + 0x2000 + lVar7 * 8) = *(undefined8 *)(param_2 + lVar11); + lVar11 = lVar12 * 8; + lVar12 = lVar12 + iVar16 * 0x400; + *(ulonglong *)(param_4 + 0x2008 + lVar7 * 8) = + *(ulonglong *)(param_2 + lVar11) ^ _DAT_181c5e520; + lVar11 = lVar6 * 8; + lVar6 = lVar6 + iVar2; + *(undefined8 *)(param_4 + 0x2010 + lVar7 * 8) = *(undefined8 *)(param_2 + lVar11); + lVar11 = lVar5 * 8; + lVar5 = lVar5 + iVar16 * 0x400; + *(ulonglong *)(param_4 + 0x2018 + lVar7 * 8) = + *(ulonglong *)(param_2 + lVar11) ^ _DAT_181c5e520; + } while (uVar15 < uVar10 >> 10); + iVar8 = uVar14 + 2 + uVar15; + } + uVar15 = iVar8 - 1; + if (uVar15 < (uint)((int)(((uint)((int)uVar10 >> 8) >> 0x17) + 0x1ff + uVar17) >> 9)) { + *(undefined8 *)(param_4 + 0x1ff0 + (longlong)(iVar8 * 2) * 8) = + *(undefined8 *) + (param_2 + (longlong)(int)(uVar17 * iVar16 + uVar15 * iVar16 * -0x200) * 8); + *(ulonglong *)(param_4 + 0x1ff8 + (longlong)(iVar8 * 2) * 8) = + *(ulonglong *)(param_2 + (longlong)(int)(iVar16 * 0x200 * uVar15) * 8) ^ _DAT_181c5e520 + ; + } + } + } + return lVar4; +} + + + +############ FUN_ 180034280 size=156 ############ + +undefined4 * FUN_180034280(int param_1,undefined4 *param_2) + +{ + int iVar1; + int iVar2; + longlong lVar3; + longlong lVar4; + int iVar5; + + if (1 < param_1) { + iVar2 = 1 << (param_1 + 0x1eU & 0x1f); + iVar1 = 0; + lVar3 = (longlong)iVar2; + iVar2 = iVar2 >> 1; + lVar4 = 1; + if (1 < lVar3) { + do { + iVar5 = iVar2; + if (iVar2 <= iVar1) { + do { + iVar1 = iVar1 - iVar5; + iVar5 = iVar5 >> 1; + } while (iVar5 <= iVar1); + } + iVar1 = iVar1 + iVar5; + param_2[lVar4] = iVar1 * 2; + lVar4 = lVar4 + 1; + } while (lVar4 < lVar3); + } + *param_2 = 0; + param_2[lVar3] = 0; + return (undefined4 *) + ((longlong)(param_2 + lVar3 + 1) + (-((ulonglong)(param_2 + lVar3 + 1) & 0x3f) & 0x3f)); + } + return param_2; +} + + + +############ FUN_ 180039b00 size=1939 ############ + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +longlong FUN_180039b00(uint param_1,ulonglong param_2) + +{ + double *pdVar1; + ulonglong *puVar2; + undefined8 *puVar3; + bool bVar4; + bool bVar5; + bool bVar6; + uint uVar7; + uint uVar8; + ulonglong uVar9; + uint uVar10; + int iVar11; + longlong lVar12; + uint uVar13; + ulonglong uVar14; + ulonglong uVar15; + uint uVar16; + longlong lVar17; + longlong lVar18; + ulonglong uVar19; + longlong lVar20; + int iVar21; + ulonglong uVar22; + undefined1 auVar23 [16]; + undefined1 auVar24 [16]; + undefined1 auVar25 [16]; + undefined1 auVar26 [16]; + undefined1 auVar27 [16]; + undefined1 auVar28 [16]; + undefined1 auVar29 [32]; + undefined1 auVar30 [32]; + undefined1 auVar31 [32]; + undefined1 auVar32 [32]; + undefined1 auVar33 [32]; + double dVar34; + undefined1 auVar35 [16]; + double dVar36; + + iVar11 = 1 << (param_1 & 0x1f); + uVar10 = (int)(((uint)(iVar11 >> 1) >> 0x1e) + iVar11) >> 2; + if ((int)param_1 < 0xb) { + if ((int)uVar10 < 1) { + lVar12 = (longlong)(int)uVar10 * 8; + } + else { + if ((int)uVar10 < 7) { + lVar12 = (longlong)(int)uVar10 * 8; + goto LAB_180039ce5; + } + iVar11 = 1 << (10 - param_1 & 0x1f); + lVar18 = (longlong)iVar11; + lVar17 = (longlong)(int)uVar10; + if (iVar11 * 8 < 1) { +LAB_180039cdd: + lVar12 = lVar17 * 8; + } + else if (param_2 < 0x182616800) { + lVar12 = lVar17 * 8; + if (lVar12 <= (longlong)((longlong)&DAT_182616800 - param_2)) { +LAB_180039bbf: + lVar12 = lVar17 * 8; + if ((int)uVar10 < 0xb) { + uVar14 = 0; + uVar16 = uVar10 & 0xfffffffe; +LAB_180039c37: + lVar17 = uVar14 * lVar18; + do { + puVar2 = &DAT_182616800 + lVar17; + auVar35._8_8_ = 0; + auVar35._0_8_ = *puVar2; + lVar17 = lVar17 + lVar18 * 2; + auVar35 = vmovhpd_avx(auVar35,puVar2[lVar18]); + *(undefined1 (*) [16])(param_2 + uVar14 * 8) = auVar35; + uVar14 = uVar14 + 2; + } while (uVar14 < (ulonglong)(longlong)(int)uVar16); + } + else { + uVar14 = param_2 & 0xf; + if ((param_2 & 7) == 0) { + if ((int)uVar14 != 0) { + uVar14 = 1; + } + } + else { + uVar14 = 0; + } + iVar21 = (int)uVar14; + if (iVar21 + 2 <= (int)uVar10) { + uVar19 = 0; + uVar16 = uVar10 - (uVar10 - iVar21 & 1); + if (iVar21 != 0) { + lVar17 = 0; + do { + puVar3 = &DAT_182616800 + lVar17; + lVar17 = lVar17 + lVar18; + *(undefined8 *)(param_2 + uVar19 * 8) = *puVar3; + uVar19 = uVar19 + 1; + } while (uVar19 < uVar14); + } + goto LAB_180039c37; + } + uVar16 = 0; + } + uVar7 = 0; + lVar17 = 0; + if (uVar16 + 1 <= uVar10) { + lVar20 = (longlong)(int)(iVar11 * uVar16); + do { + uVar7 = uVar7 + 1; + *(undefined8 *)(param_2 + (longlong)(int)uVar16 * 8 + lVar17 * 8) = + (&DAT_182616800)[lVar20]; + lVar20 = lVar20 + lVar18; + lVar17 = lVar17 + 1; + } while (uVar7 < uVar10 - uVar16); + } + goto LAB_180039db6; + } + } + else { + if (param_2 < 0x182616801) goto LAB_180039cdd; + lVar12 = lVar17 * 8; + if ((lVar17 + -1) * (longlong)(iVar11 * 8) + 8 <= (longlong)(param_2 - 0x182616800)) + goto LAB_180039bbf; + } +LAB_180039ce5: + iVar11 = 1; + if (uVar10 >> 1 != 0) { + iVar11 = 1 << (10 - param_1 & 0x1f); + lVar18 = (longlong)iVar11; + lVar20 = (longlong)(iVar11 * 2); + lVar17 = 0; + uVar16 = 0; + do { + uVar7 = uVar16; + puVar3 = &DAT_182616800 + lVar17; + uVar16 = uVar7 + 1; + lVar17 = lVar17 + lVar20; + *(undefined8 *)(param_2 + (longlong)(int)(uVar7 * 2) * 8) = *puVar3; + puVar3 = &DAT_182616800 + lVar18; + lVar18 = lVar18 + lVar20; + *(undefined8 *)(param_2 + 8 + (longlong)(int)(uVar7 * 2) * 8) = *puVar3; + } while (uVar16 < uVar10 >> 1); + iVar11 = uVar7 + 2 + uVar16; + } + if (iVar11 - 1U < uVar10) { + *(undefined8 *)((param_2 - 8) + (longlong)iVar11 * 8) = + (&DAT_182616800)[(int)((1 << (10 - param_1 & 0x1f)) * (iVar11 - 1U))]; + } + } +LAB_180039db6: + *(undefined8 *)(lVar12 + param_2) = 0x3ff0000000000000; + goto LAB_18003a23f; + } + iVar21 = (int)(((uint)(iVar11 >> 2) >> 0x1d) + iVar11) >> 3; + dVar36 = DAT_181c5e3f0 / (double)iVar11; + uVar16 = iVar21 + 1; + if (-1 < iVar21) { + if ((int)uVar16 < 0x10) { +LAB_18003a28c: + uVar8 = 0; + } + else { + uVar14 = param_2 & 0x1f; + if ((param_2 & 7) == 0) { + if ((int)uVar14 != 0) { + uVar14 = (ulonglong)(0x20U - (int)uVar14 >> 3); + } + } + else { + uVar14 = 0; + } + uVar7 = (uint)uVar14; + if ((int)uVar16 < (int)(uVar7 + 0x10)) goto LAB_18003a28c; + uVar13 = 0; + lVar12 = 0; + uVar8 = uVar16 - (uVar16 - uVar7 & 0xf); + if (uVar7 != 0) { + do { + dVar34 = (double)(int)uVar13; + uVar13 = uVar13 + 1; + *(double *)(param_2 + lVar12 * 8) = dVar36 * dVar34; + lVar12 = lVar12 + 1; + } while (uVar13 < uVar7); + } + auVar35 = _DAT_181c5e3d0; + auVar23 = vpunpcklqdq_avx512vl(ZEXT416(uVar7),ZEXT416(uVar7 + 1)); + auVar24 = vpunpcklqdq_avx512vl(ZEXT416(uVar7 + 2),ZEXT416(uVar7 + 3)); + auVar23 = vshufps_avx512vl(auVar23,auVar24,0x88); + auVar32._8_8_ = dVar36; + auVar32._0_8_ = dVar36; + auVar32._16_8_ = dVar36; + auVar32._24_8_ = dVar36; + do { + auVar24 = vpaddd_avx512vl(auVar23,auVar35); + auVar25 = vpaddd_avx512vl(auVar24,auVar35); + auVar26 = vpaddd_avx512vl(auVar25,auVar35); + auVar33 = vcvtdq2pd_avx(auVar23); + auVar29 = vcvtdq2pd_avx512vl(auVar24); + auVar30 = vcvtdq2pd_avx512vl(auVar25); + auVar31 = vcvtdq2pd_avx512vl(auVar26); + auVar29 = vmulpd_avx512vl(auVar32,auVar29); + auVar23 = vpaddd_avx512vl(auVar26,auVar35); + auVar30 = vmulpd_avx512vl(auVar32,auVar30); + auVar31 = vmulpd_avx512vl(auVar32,auVar31); + pdVar1 = (double *)(param_2 + uVar14 * 8); + *pdVar1 = dVar36 * auVar33._0_8_; + pdVar1[1] = dVar36 * auVar33._8_8_; + pdVar1[2] = dVar36 * auVar33._16_8_; + pdVar1[3] = dVar36 * auVar33._24_8_; + *(undefined1 (*) [32])(param_2 + 0x20 + uVar14 * 8) = auVar29; + *(undefined1 (*) [32])(param_2 + 0x40 + uVar14 * 8) = auVar30; + *(undefined1 (*) [32])(param_2 + 0x60 + uVar14 * 8) = auVar31; + uVar14 = uVar14 + 0x10; + } while (uVar14 < (ulonglong)(longlong)(int)uVar8); + } + auVar35 = _DAT_181c5e3d0; + if (uVar8 + 1 <= uVar16) { + auVar23 = vpunpcklqdq_avx512vl(ZEXT416(uVar8),ZEXT416(uVar8 + 1)); + uVar14 = 0; + auVar24 = vpunpcklqdq_avx512vl(ZEXT416(uVar8 + 2),ZEXT416(uVar8 + 3)); + auVar23 = vshufps_avx512vl(auVar23,auVar24,0x88); + auVar33._8_8_ = dVar36; + auVar33._0_8_ = dVar36; + auVar33._16_8_ = dVar36; + auVar33._24_8_ = dVar36; + auVar25 = vpbroadcastd_avx512vl(); + lVar12 = 0; + auVar24 = _DAT_181c5e3e0; + do { + auVar32 = vcvtdq2pd_avx512vl(auVar23); + uVar14 = uVar14 + 4; + auVar23 = vpaddd_avx(auVar23,auVar35); + uVar19 = vpcmpgtd_avx512vl(auVar25,auVar24); + uVar19 = uVar19 & 0xf; + auVar24 = vpaddd_avx(auVar24,auVar35); + auVar32 = vmulpd_avx512vl(auVar33,auVar32); + puVar2 = (ulonglong *)(lVar12 + param_2 + (longlong)(int)uVar8 * 8); + bVar4 = (bool)((byte)uVar19 & 1); + bVar5 = (bool)((byte)(uVar19 >> 1) & 1); + bVar6 = (bool)((byte)(uVar19 >> 2) & 1); + *puVar2 = (ulonglong)bVar4 * auVar32._0_8_ | (ulonglong)!bVar4 * *puVar2; + puVar2[1] = (ulonglong)bVar5 * auVar32._8_8_ | (ulonglong)!bVar5 * puVar2[1]; + puVar2[2] = (ulonglong)bVar6 * auVar32._16_8_ | (ulonglong)!bVar6 * puVar2[2]; + puVar2[3] = (uVar19 >> 3) * auVar32._24_8_ | (ulonglong)!SUB81(uVar19 >> 3,0) * puVar2[3]; + lVar12 = lVar12 + 0x20; + } while (uVar14 < (ulonglong)((longlong)(int)uVar16 - (longlong)(int)uVar8)); + } + } + auVar35 = _DAT_181c5e3d0; + uVar7 = uVar10 - iVar21; + if ((int)uVar10 < (int)uVar16) { + uVar14 = param_2 + 8 + (longlong)iVar21 * 8; + } + else { + lVar12 = param_2 + (longlong)iVar21 * 8; + uVar14 = lVar12 + 8; + if ((int)uVar7 < 0x10) { + uVar19 = 0; + } + else { + uVar8 = (uint)uVar14 & 0x1f; + if ((uVar14 & 7) == 0) { + if (((uVar14 & 0x1f) != 0) && (uVar8 = 0x20 - uVar8 >> 3, (int)uVar7 < (int)uVar8)) { + uVar8 = uVar7; + } + } + else { + uVar8 = 0; + } + uVar13 = uVar7 - uVar8 & 0xf; + uVar19 = (longlong)(int)uVar7 - (ulonglong)uVar13; + uVar15 = (ulonglong)(int)uVar8; + if (uVar8 != 0) { + auVar27 = vmovdqu32_avx512vl(_DAT_181c5e3e0); + auVar24 = vpbroadcastd_avx512vl(); + auVar25 = vpbroadcastd_avx512vl(); + auVar23 = vpunpcklqdq_avx512vl(ZEXT416(uVar16),ZEXT416(iVar21 + 2)); + uVar9 = 0; + auVar29._8_8_ = dVar36; + auVar29._0_8_ = dVar36; + auVar29._16_8_ = dVar36; + auVar29._24_8_ = dVar36; + auVar26 = vpunpcklqdq_avx512vl(ZEXT416(iVar21 + 3),ZEXT416(iVar21 + 4)); + auVar23 = vshufps_avx512vl(auVar23,auVar26,0x88); + lVar17 = 0; + do { + auVar26 = vpsubd_avx512vl(auVar24,auVar23); + uVar9 = uVar9 + 4; + auVar32 = vcvtdq2pd_avx512vl(auVar26); + auVar23 = vpaddd_avx(auVar23,auVar35); + uVar22 = vpcmpgtd_avx512vl(auVar25,auVar27); + uVar22 = uVar22 & 0xf; + auVar27 = vpaddd_avx512vl(auVar27,auVar35); + auVar32 = vmulpd_avx512vl(auVar29,auVar32); + puVar2 = (ulonglong *)(lVar17 + 8 + lVar12); + bVar4 = (bool)((byte)uVar22 & 1); + bVar5 = (bool)((byte)(uVar22 >> 1) & 1); + bVar6 = (bool)((byte)(uVar22 >> 2) & 1); + *puVar2 = (ulonglong)bVar4 * auVar32._0_8_ | (ulonglong)!bVar4 * *puVar2; + puVar2[1] = (ulonglong)bVar5 * auVar32._8_8_ | (ulonglong)!bVar5 * puVar2[1]; + puVar2[2] = (ulonglong)bVar6 * auVar32._16_8_ | (ulonglong)!bVar6 * puVar2[2]; + puVar2[3] = (uVar22 >> 3) * auVar32._24_8_ | (ulonglong)!SUB81(uVar22 >> 3,0) * puVar2[3]; + lVar17 = lVar17 + 0x20; + } while (uVar9 < uVar15); + if (uVar7 == uVar8) goto LAB_18003a220; + } + uVar16 = uVar8 + 1 + iVar21; + auVar23 = vpunpcklqdq_avx512vl(ZEXT416(uVar16),ZEXT416(uVar16 + 1)); + auVar24 = vpunpcklqdq_avx512vl(ZEXT416(uVar16 + 2),ZEXT416(uVar16 + 3)); + auVar23 = vshufps_avx512vl(auVar23,auVar24,0x88); + if ((longlong)(uVar15 + 0x10) <= (longlong)uVar19) { + auVar24 = vpbroadcastd_avx512vl(); + auVar30._8_8_ = dVar36; + auVar30._0_8_ = dVar36; + auVar30._16_8_ = dVar36; + auVar30._24_8_ = dVar36; + do { + auVar25 = vpaddd_avx512vl(auVar23,auVar35); + auVar23 = vpsubd_avx(auVar24,auVar23); + auVar26 = vpaddd_avx512vl(auVar25,auVar35); + auVar25 = vpsubd_avx512vl(auVar24,auVar25); + auVar27 = vpaddd_avx512vl(auVar26,auVar35); + auVar26 = vpsubd_avx512vl(auVar24,auVar26); + auVar28 = vpsubd_avx512vl(auVar24,auVar27); + auVar32 = vcvtdq2pd_avx512vl(auVar23); + auVar33 = vcvtdq2pd_avx512vl(auVar25); + auVar23 = vpaddd_avx512vl(auVar27,auVar35); + auVar29 = vcvtdq2pd_avx512vl(auVar26); + auVar31 = vcvtdq2pd_avx512vl(auVar28); + auVar32 = vmulpd_avx512vl(auVar30,auVar32); + auVar33 = vmulpd_avx512vl(auVar30,auVar33); + auVar29 = vmulpd_avx512vl(auVar30,auVar29); + auVar31 = vmulpd_avx512vl(auVar30,auVar31); + *(undefined1 (*) [32])(lVar12 + 8 + uVar15 * 8) = auVar32; + *(undefined1 (*) [32])(lVar12 + 0x28 + uVar15 * 8) = auVar33; + *(undefined1 (*) [32])(lVar12 + 0x48 + uVar15 * 8) = auVar29; + *(undefined1 (*) [32])(lVar12 + 0x68 + uVar15 * 8) = auVar31; + uVar15 = uVar15 + 0x10; + } while (uVar15 < uVar19); + if (uVar13 == 0) goto LAB_18003a220; + } + } + lVar12 = lVar12 + uVar19 * 8; + iVar11 = (uVar7 - 1) - (int)uVar19; + do { + uVar16 = (int)uVar19 + 1; + uVar19 = (ulonglong)uVar16; + dVar34 = (double)iVar11; + iVar11 = iVar11 + -1; + *(double *)(lVar12 + 8) = dVar36 * dVar34; + lVar12 = lVar12 + 8; + } while ((int)uVar16 < (int)uVar7); + } +LAB_18003a220: + thunk_FUN_1801de760(param_2,param_2); + thunk_FUN_1801e3f20(uVar14,uVar14,uVar7); +LAB_18003a23f: + uVar14 = param_2 + 8 + (longlong)(int)uVar10 * 8; + return uVar14 + (-(uVar14 & 0x3f) & 0x3f); +} + + + diff --git a/roadmap.md b/roadmap.md index 19027d4..914d5d7 100644 --- a/roadmap.md +++ b/roadmap.md @@ -80,9 +80,17 @@ SIMD `divpd`+`thunk_FUN_181a114e0(=cos)`). Размер N: `FUN_18052e130` → `N = 2^floor(log2(sr/44100))·N0` (44100 @0x1824c45ec, 2.0 @41e8). **Нормализация окна** в `FUN_18052df60`: сумма по окну → `scale=1/(mean/N)`, потом `/= (fsize @+0x1ac)`. -- **A.3 FFT — НЕ подтверждён для DSP**: найденный планировщик `FUN_181384180` (radix-4/8 стадии, - cos/sin twiddle, бит-реверс, log2(N)) — это **Vorbis-декодер** (строка `s_vorbis_1821e47fc`); - в DSP-пути не участвует. В бинарнике нет kissfft/fftw/MKL-FFT строк. DSP-STFT-FFT ищется дальше. +- **A.3 FFT — НАЙДЕН (свой)**: Vorbis-планировщик `FUN_181384180` — не тот (это декодер). + Настоящий DSP-FFT: `FUN_180008140` = init FFT-spec (`N=1<