From e4e973f204990654f84e1312e899e7fe25e80f4c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?John=20K=C3=A4ll=C3=A9n?= Date: Mon, 14 Oct 2024 23:33:59 +0200 Subject: [PATCH] Feature: partial implementation of #3 On some architectures, we can fit a whole address in an instruction operand (e.g. X86, Vax, M68k). On other, Risc-y architectures the addresses are commonly split into `load-high` + `load-low` pairs. More work is needed to address those. --- src/Core/Output/Dumper.cs | 2 +- src/Core/Output/FormatterInstructionWriter.cs | 15 +- src/Gui/TextViewing/DisassemblyFormatter.cs | 4 + .../WebAssembly/Output/CodeSectionRenderer.cs | 9 +- .../Scanning/BackwardSlicerTests.cs | 43 +- .../WindowsForms/DisassemblyViewInteractor.cs | 6 +- .../ArTar/hello.reko/hello_O1_init.asm | 2 +- .../ArTar/hello.reko/hello_O1_text.asm | 26 +- subjects/Elf/Msp430/a.reko/a_text.asm | 20 +- subjects/Elf/RiscV/ipcalc/ipcalc_plt.dis | 503 +- subjects/Elf/RiscV/ipcalc/ipcalc_text.dis | 5773 +++++------------ .../ping/ping.reko/ping_text_0000.asm | 962 +-- .../ais3_crackme.reko/ais3_crackme_text.asm | 12 +- subjects/Elf/x86-64/ls/ls.reko/ls_init.asm | 2 +- subjects/Elf/x86-64/ls/ls.reko/ls_text.asm | 174 +- .../pngpixel/pngpixel.reko/pngpixel_init.asm | 2 +- .../pngpixel/pngpixel.reko/pngpixel_text.asm | 18 +- .../retpoline.reko/retpoline_init.asm | 2 +- .../retpoline.reko/retpoline_text.asm | 10 +- .../retpoline_stripped_init.asm | 2 +- .../retpoline_stripped_text.asm | 2 +- .../simd_double.reko/simd_double_init.asm | 2 +- .../simd_double.reko/simd_double_text.asm | 28 +- .../zSeries/fib/example.reko/example_text.asm | 22 +- .../MachO-OSX-x64-ls_TEXT_stubs.asm | 148 +- .../MachO-OSX-x64-ls_TEXT_text.asm | 34 +- .../varargs_test.reko/varargs_test_text.asm | 48 +- .../Executable.reko/Executable_text.asm | 42 +- .../LocalStackVariables_text.asm | 4 +- .../UserDefinedSignatures_text.asm | 8 +- .../VCExeSample.reko/VCExeSample_text.asm | 2 +- subjects/PE/x86/import-ordinals/main_text.asm | 30 +- subjects/PE/x86/pySample/pySample_text.asm | 56 +- .../shingledPySample.reko/pySample_text.asm | 62 +- subjects/regression.log | 6 +- .../angr-148/test.reko/test_init.asm | 2 +- .../angr-148/test.reko/test_text.asm | 10 +- .../regressions/reko-351/a.reko/a_text.asm | 28 +- 38 files changed, 2910 insertions(+), 5211 deletions(-) diff --git a/src/Core/Output/Dumper.cs b/src/Core/Output/Dumper.cs index d4554f3cee..abe4d37bb6 100644 --- a/src/Core/Output/Dumper.cs +++ b/src/Core/Output/Dumper.cs @@ -222,7 +222,7 @@ public void DumpAssembler( var flags = MachineInstructionRendererFlags.ResolvePcRelativeAddress; if (this.RenderInstructionsCanonically) flags |= MachineInstructionRendererFlags.RenderInstructionsCanonically; - var writer = new FormatterInstructionWriter(formatter, program.Procedures, true); + var writer = new FormatterInstructionWriter(formatter, program.Procedures, program.ImageSymbols, true); var options = new MachineInstructionRendererOptions( flags: flags, syntax: ""); diff --git a/src/Core/Output/FormatterInstructionWriter.cs b/src/Core/Output/FormatterInstructionWriter.cs index c6d32f2515..d24498ccc0 100644 --- a/src/Core/Output/FormatterInstructionWriter.cs +++ b/src/Core/Output/FormatterInstructionWriter.cs @@ -18,7 +18,9 @@ */ #endregion +using Reko.Core.Loading; using Reko.Core.Machine; +using System; using System.Collections.Generic; namespace Reko.Core.Output @@ -31,6 +33,7 @@ public class FormatterInstructionWriter : MachineInstructionRenderer { private readonly Formatter formatter; private readonly IDictionary procedures; + private readonly IDictionary symbols; private readonly bool separateWithTab; private int chars; private readonly List annotations; @@ -43,10 +46,15 @@ public class FormatterInstructionWriter : MachineInstructionRenderer /// machine rendering is sent. /// If true, separate the mnemonic and the /// first operand with a tab, otherwise use a single space. - public FormatterInstructionWriter(Formatter formatter, IDictionary procedures, bool separateWithTab) + public FormatterInstructionWriter( + Formatter formatter, + IDictionary procedures, + IDictionary symbols, + bool separateWithTab) { this.formatter = formatter; this.procedures = procedures; + this.symbols = symbols; this.separateWithTab = separateWithTab; this.annotations = new List(); this.addrInstr = Address.Ptr32(0); @@ -118,6 +126,11 @@ public void WriteAddress(string formattedAddress, Address addr) { formattedAddress = proc.Name; } + else if (symbols.TryGetValue(addr, out var symbol)) + { + formattedAddress = symbol.Name ?? formattedAddress; + } + chars += formattedAddress.Length; formatter.WriteHyperlink(formattedAddress, addr); } diff --git a/src/Gui/TextViewing/DisassemblyFormatter.cs b/src/Gui/TextViewing/DisassemblyFormatter.cs index b19889fca1..4b102e286f 100644 --- a/src/Gui/TextViewing/DisassemblyFormatter.cs +++ b/src/Gui/TextViewing/DisassemblyFormatter.cs @@ -93,6 +93,10 @@ public void WriteAddress(string formattedAddress, Address addr) { span = factory.CreateProcedureTextSpan(proc, addr); } + else if (program.ImageSymbols.TryGetValue(addr, out var symbol)) + { + span = factory.CreateAddressTextSpan(addr, symbol.Name ?? formattedAddress); + } else { span = factory.CreateAddressTextSpan(addr, formattedAddress); diff --git a/src/ImageLoaders/WebAssembly/Output/CodeSectionRenderer.cs b/src/ImageLoaders/WebAssembly/Output/CodeSectionRenderer.cs index acabf3ae44..9409f18cc8 100644 --- a/src/ImageLoaders/WebAssembly/Output/CodeSectionRenderer.cs +++ b/src/ImageLoaders/WebAssembly/Output/CodeSectionRenderer.cs @@ -71,9 +71,14 @@ public void RenderFunction(FunctionDefinition function, Formatter formatter) var mem = new ByteMemoryArea(Address.Ptr32(0x1_0000), codeSection.Bytes); var rdr = new LeImageReader(mem, function.Start, function.End); var dasm = arch.CreateDisassembler(rdr); - //$TODO provide real procedures. + //$TODO provide real procedures and image symbols. var procedures = new Dictionary(); - var instrRenderer = new FormatterInstructionWriter(formatter, procedures, false); + var symbols = new Dictionary(); + var instrRenderer = new FormatterInstructionWriter( + formatter, + procedures, + symbols, + false); var options = new MachineInstructionRendererOptions(); var dataStack = new List(); var blockStack = new List(); diff --git a/src/UnitTests/Decompiler/Scanning/BackwardSlicerTests.cs b/src/UnitTests/Decompiler/Scanning/BackwardSlicerTests.cs index a3125a8dbb..e4b07b3a48 100644 --- a/src/UnitTests/Decompiler/Scanning/BackwardSlicerTests.cs +++ b/src/UnitTests/Decompiler/Scanning/BackwardSlicerTests.cs @@ -1576,12 +1576,12 @@ 0000000000401211 goto rax Assert.AreEqual("1[0,2]", bwslc.JumpTableIndexInterval.ToString()); Assert.AreEqual("004011FB", bwslc.GuardInstrAddress.ToString()); } + /* - [Test] - public void Bwslc_RiscV_64bit() - { - /* - * + [Test] + public void Bwslc_RiscV_64bit() + { + * 0000000000015214 F0EF DDDF jal getopt_long 0000000000015218 0713 FFF0 li a4,-0x1 000000000001521C 0793 0005 mv a5,a0 @@ -1597,24 +1597,24 @@ 0000000000015214 F0EF DDDF jal getopt_long 000000000001523C 87B3 00E7 add a5,a5,a4 0000000000015240 A783 0007 lw a5,(a5) 0000000000015244 8067 0007 jalr zero,a5,0x0 - * - call get_optt - a4 = -1 - a5 = a0 - branch a0 == a4 l0000000000015348 +* +call get_optt +a4 = -1 +a5 = a0 +branch a0 == a4 l0000000000015348 l0000000000015224: - a4 = 118 - branch a4 >u 0x1E - a4 = a4 + 672 - a5 = a5 + a4 - a5 = CONVERT(Mem0[a5:int32], int32, int64) - call a5 (retsize: 0;) -*/ - var l15214 = Given_Block(0x0000000000015214ul); +a5 = a5 << 0x20 +a4 = 0x00010000 +a5 = a5 >>u 0x1E +a4 = a4 + 672 +a5 = a5 + a4 +a5 = CONVERT(Mem0[a5:int32], int32, int64) +call a5 (retsize: 0;) + + var l15214 = Given_Block(0x0000000000015214ul); var l15224 = Given_Block(0x0000000000015224ul); var l1522C = Given_Block(0x000000000001522Cul); var bye = Given_Block(0x0000000000015200ul); @@ -1668,6 +1668,7 @@ branch a4 - t3 = Mem0[t3:word64] - t1 = 0x000000000001510C - call t3 (retsize: 0;) + t3_5 = Mem0[0x000000000001A100:word64] + call t3_5 (retsize: 0;) + uses: Mem:Mem0,t1:0x000000000001510C,t3:t3_5 return - // succ: fputc_exit fputc_exit: -// __stack_chk_fail -// Return size: 0 -define __stack_chk_fail -__stack_chk_fail_entry: +void __stack_chk_fail() +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// MayUse: +// LiveOut: +// Trashed: +// Preserved: +// Terminates process __stack_chk_fail_exit: +__stack_chk_fail_entry: -// __errno_location -// Return size: 0 -define __errno_location -__errno_location_entry: +void __errno_location() +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// MayUse: +// LiveOut: +// Trashed: +// Preserved: +// Terminates process __errno_location_exit: +__errno_location_entry: -// strtol -// Return size: 0 -define strtol -strtol_entry: +void strtol() +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// MayUse: +// LiveOut: +// Trashed: +// Preserved: +// Terminates process strtol_exit: +strtol_entry: -// strchr -// Return size: 0 -define strchr -strchr_entry: +void strchr() +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// MayUse: +// LiveOut: +// Trashed: +// Preserved: +// Terminates process strchr_exit: +strchr_entry: -// memcpy -// Return size: 0 -define memcpy -memcpy_entry: +void memcpy() +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// MayUse: +// LiveOut: +// Trashed: +// Preserved: +// Terminates process memcpy_exit: +memcpy_entry: -// abort -// Return size: 0 -define abort -abort_entry: +void abort() +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// MayUse: +// LiveOut: +// Trashed: +// Preserved: +// Terminates process abort_exit: +abort_entry: -// freeaddrinfo -// Return size: 0 -define freeaddrinfo -freeaddrinfo_entry: +void freeaddrinfo() +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// MayUse: +// LiveOut: +// Trashed: +// Preserved: +// Terminates process freeaddrinfo_exit: +freeaddrinfo_entry: diff --git a/subjects/Elf/RiscV/ipcalc/ipcalc_text.dis b/subjects/Elf/RiscV/ipcalc/ipcalc_text.dis index f8fcb71f0f..6c53722400 100644 --- a/subjects/Elf/RiscV/ipcalc/ipcalc_text.dis +++ b/subjects/Elf/RiscV/ipcalc/ipcalc_text.dis @@ -1,4601 +1,2086 @@ -// fn0000000000015180 -// Return size: 0 -define fn0000000000015180 +void fn0000000000015180(word64 ra, word64 gp, word64 a0, word64 a1, word64 a7, word64 s5, word64 s11) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// MayUse: a0:[0..63] a1:[0..63] a7:[0..63] gp:[0..63] ra:[0..63] s11:[0..63] s5:[0..63] +// LiveOut: +// Trashed: a0 a1 a2 a3 a4 a5 a6 a7 gp ra s0 s1 s10 s11 s2 s3 s4 s5 s6 s7 s8 s9 t1 t3 +// Preserved: sp fn0000000000015180_entry: - sp = fp - // succ: l0000000000015180 l0000000000015180: - sp = sp + -448 - Mem0[sp + 392:word64] = s5 - a5 = Mem0[gp + -1936:word64] - Mem0[sp + 424:word64] = s1 - s1 = 0x11000<64> - Mem0[sp + 328:word64] = a5 - a5 = 0x10000<64> - v8 = SLICE(a5, word32, 0) - a5 = CONVERT(v8 + 8, word32, int64) - Mem0[sp + 432:word64] = s0 - Mem0[sp + 416:word64] = s2 - Mem0[sp + 408:word64] = s3 - Mem0[sp + 400:word64] = s4 - Mem0[sp + 384:word64] = s6 - Mem0[sp + 376:word64] = s7 - Mem0[sp + 368:word64] = s8 - Mem0[sp + 360:word64] = s9 - Mem0[sp + 352:word64] = s10 - Mem0[sp + 344:word64] = s11 - Mem0[sp + 440:word64] = ra - s8 = 0x1000<64> - s3 = a0 - s2 = a1 - Mem0[sp + 28:word32] = SLICE(0<64>, word32, 0) - s0 = 0 - s6 = 0 - s9 = 0 - s10 = 0 - Mem0[sp:word32] = SLICE(0<64>, word32, 0) - s1 = s1 + -1824 - s4 = 0x12000<64> - s7 = 1 - Mem0[sp + 8:word32] = SLICE(a5, word32, 0) - // succ: l0000000000015200 + a5_7 = Mem5[gp + -1936:word64] + Mem42[&qwLoc01A8 + 4:word32] = 0<32> + s0_131 = 0 l0000000000015200: - a4 = 0 - a3 = s1 - a2 = s4 + -1624 - a1 = s2 - a0 = s3 - a0 = SEQ(0<32>, getopt_long(SLICE(a0, int32, 0), a1, a2, a3, a4)) - a4 = -1 - a5 = a0 - branch a0 == a4 l0000000000015348 - // succ: l0000000000015224 l0000000000015348 -l0000000000015224: - a4 = 118 - branch a4 - a4 = 0x10000<64> - a5 = a5 >>u 0x1E - a4 = a4 + 672 - a5 = a5 + a4 - a5 = CONVERT(Mem0[a5:int32], int32, int64) - call a5 (retsize: 0;) - return - // succ: fn0000000000015180_exit + a0_61 = CONVERT(getopt_long(SLICE(a0, int32, 0), a1, 0x119A8<64>, 0x108E0<64>, 0), uint32, uint64) + branch a0_61 == -1 l0000000000015348 l0000000000015348: - a4 = CONVERT(Mem0[gp + -1904:int32], int32, int64) - branch a4 >= s3 l0000000000015428 - // succ: l0000000000015350 l0000000000015428 + a4_66 = CONVERT(Mem51[gp + -1904:int32], int32, int64) + branch a4_66 >= a0 l0000000000015428 +l0000000000015428: + s4_333 = 0 + s1_144 = 0 l0000000000015350: - v30 = SLICE(a4, word32, 0) - a1 = CONVERT(v30 + 1, word32, int64) - a3 = a4 << 3 - s2 = s2 + a3 - Mem0[gp + -1904:word32] = SLICE(a1, word32, 0) - s1 = Mem0[s2:word64] - s4 = 0 - branch a1 >= s3 l0000000000015378 - // succ: l000000000001536C l0000000000015378 + a1_70 = CONVERT(SLICE(a4_66, word32, 0) + 1, word32, int64) + Mem73[gp + -1904:word32] = SLICE(a1_70, word32, 0) + s2_72 = a1 + (a4_66 << 3) + s1_144 = Mem73[s2_72:word64] + s4_333 = 0 + branch a1_70 >= a0 l0000000000015378 l000000000001536C: - s4 = Mem0[s2 + 8:word64] - v31 = SLICE(a4, word32, 0) - a4 = CONVERT(v31 + 2, word32, int64) - Mem0[gp + -1904:word32] = SLICE(a4, word32, 0) - // succ: l0000000000015378 + s4_333 = Mem73[s2_72 + 8:word64] + Mem79[gp + -1904:word32] = SLICE(a4_66, word32, 0) + 2 l0000000000015378: - branch s6 != 0<64> l0000000000015588 - // succ: l000000000001537C l0000000000015588 + branch false l0000000000015588 +l0000000000015588: + __printf_chk(1, 0x119C8<64>, 0x119C0<64>) l000000000001537C: - a4 = CONVERT(Mem0[sp + 28:int32], int32, int64) - branch a4 == 0<64> l00000000000153B4 - // succ: l0000000000015384 l00000000000153B4 + branch CONVERT(Mem91[&qwLoc01A8 + 4:int32], int32, int64) == 0<64> l00000000000153B4 l0000000000015384: - a4 = CONVERT(Mem0[sp:int32], int32, int64) - branch a4 == 0<64> l00000000000153B4 - // succ: l000000000001538C l00000000000153B4 -l000000000001538C: - a5 = CONVERT(Mem0[gp + -2028:int32], int32, int64) - branch a5 != 0<64> l00000000000153D8 - // succ: l0000000000015394 l00000000000153D8 -l0000000000015394: - a3 = Mem0[gp + -1920:word64] - a0 = 0x12000<64> - a2 = 46 - a1 = 1 - a0 = a0 + -1576 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - s6 = CONVERT(Mem0[sp:int32], int32, int64) - goto l00000000000153DC - // succ: l00000000000153DC + branch true l00000000000153B4 l00000000000153B4: - Mem0[sp + 8:word64] = a5 - branch s9 == 0<64> l0000000000015924 - // succ: l00000000000153BC l0000000000015924 + branch true l0000000000015924 +l0000000000015924: + branch fn0000000000017924(gp, out a1_2672, out a2_2673, out a3_2674, out a4_2675, out a6_1018) != 0<64> l0000000000015458 +l0000000000015930: + branch true l0000000000015458 +l0000000000015940: l00000000000153BC: - call fn0000000000017924 (retsize: 0;) - s2 = s0 | 2 - a5 = Mem0[sp + 8:word64] - branch a0 == 0<64> l0000000000015434 - // succ: l00000000000153CC l0000000000015434 -l00000000000153CC: - branch s10 == 0<64> l00000000000155A8 - // succ: l00000000000153D0 l00000000000155A8 -l00000000000153D0: - a5 = CONVERT(Mem0[gp + -2028:int32], int32, int64) - branch a5 == 0<64> l000000000001556C - // succ: l00000000000153D8 l000000000001556C -l00000000000153D8: - s6 = 1 - // succ: l00000000000153DC -l00000000000153DC: - a4 = Mem0[sp + 328:word64] - a5 = Mem0[gp + -1936:word64] - a0 = s6 - branch a4 != a5 l0000000000015E8C - // succ: l00000000000153EC l0000000000015E8C -l00000000000153EC: - ra = Mem0[sp + 440:word64] - s0 = Mem0[sp + 432:word64] - s1 = Mem0[sp + 424:word64] - s2 = Mem0[sp + 416:word64] - s3 = Mem0[sp + 408:word64] - s4 = Mem0[sp + 400:word64] - s5 = Mem0[sp + 392:word64] - s6 = Mem0[sp + 384:word64] - s7 = Mem0[sp + 376:word64] - s8 = Mem0[sp + 368:word64] - s9 = Mem0[sp + 360:word64] - s10 = Mem0[sp + 352:word64] - s11 = Mem0[sp + 344:word64] - sp = sp + 448 - return - // succ: fn0000000000015180_exit -l0000000000015428: - s4 = 0 - s1 = 0 - goto l0000000000015378 - // succ: l0000000000015378 + s2_125 = 2 + branch fn0000000000017924(gp, out a1_2676, out a2_2677, out a3_2678, out a4_2679, out a6_1018) == 0<64> l0000000000015434 l0000000000015434: - a4 = 0x10000<64> - v33 = SLICE(a4, word32, 0) - a4 = CONVERT(v33 + 8, word32, int64) - s0 = s0 & a4 - branch s0 != a4 l00000000000153CC - // succ: l0000000000015444 l00000000000153CC + branch true l00000000000153CC l0000000000015444: - s0 = s2 - // succ: l0000000000015448 + s0_131 = 2 l0000000000015448: - s2 = 0x4000<64> - s2 = s0 | s2 - branch s9 != 0<64> l00000000000153CC - // succ: l0000000000015454 l00000000000153CC + s2_125 = s0_131 | 0x4000<64> + branch false l00000000000153CC l0000000000015454: - s0 = s2 - // succ: l0000000000015458 + s0_131 = s2_125 l0000000000015458: - branch s10 == 0<64> l0000000000015CE4 - // succ: l000000000001545C l0000000000015CE4 + a5_262 = a0_61 + branch true l0000000000015CE4 +l0000000000015CE4: + branch s1_144 != 0<64> l0000000000015510 +l0000000000015CE8: + branch CONVERT(Mem97[gp + -2028:int32], int32, int64) != 0<64> l00000000000153D8 +l0000000000015CF0: + fwrite(0x11A30<64>, SLICE(1, size_t, 0), SLICE(28, size_t, 0), Mem97[gp + -1920:word64]) + fn0000000000015FCC(gp, 1) l000000000001545C: - a2 = 1 - a1 = s10 - a0 = sp + 28 - call fn00000000000166F4 (retsize: 0;) - a5 = a0 - branch a0 < 0<64> l0000000000015BC8 - // succ: l0000000000015474 l0000000000015BC8 + a0_170 = fn00000000000166F4(gp, &qwLoc01A8 + 4, 0, 1) + branch a0_170 < 0<64> l0000000000015BC8 +l0000000000015BC8: + branch CONVERT(Mem97[gp + -2028:int32], int32, int64) != 0<64> l00000000000153D8 +l0000000000015BD0: + a0_179 = Mem97[gp + -1920:word64] + branch CONVERT(Mem97[&qwLoc01A8 + 4:int32], int32, int64) != 0<64> l0000000000015E7C +l0000000000015E7C: + a3_181 = 0x11998<64> + a4_182 = 0 +l0000000000015BDC: + a3_181 = 0x119A0<64> + a4_182 = 0 l0000000000015474: - a1 = sp + 40 - a0 = 2 - Mem0[sp + 8:word64] = a5 - s1 = CONVERT(Mem0[sp + 28:int32], int32, int64) - Mem0[sp + 32:word64] = 0<64> - a0 = SEQ(0<32>, clock_gettime(SLICE(a0, clockid_t, 0), a1)) - a5 = Mem0[sp + 8:word64] - branch a0 < 0<64> l0000000000015CB0 - // succ: l0000000000015494 l0000000000015CB0 + s1_189 = CONVERT(Mem188[&qwLoc01A8 + 4:int32], int32, int64) + Mem190[&ptrLoc01A0:word64] = 0<64> + branch CONVERT(clock_gettime(2, &tLoc0198), uint32, uint64) < 0<64> l0000000000015CB0 l0000000000015494: - branch s1 == 0<64> l0000000000015C48 - // succ: l0000000000015498 l0000000000015C48 + branch s1_189 == 0<64> l0000000000015C48 +l0000000000015C48: + branch fn00000000000164D0(&qwLocC0, 4) < 0<64> l0000000000015CB0 +l0000000000015C64: + branch a0_170 <= 15 l0000000000015C7C +l0000000000015C6C: + branch qwLoc0190 %s 4 <=u 1 l0000000000015DB8 +l0000000000015DB8: + branch qwLoc0190 %s 4 == 1 l0000000000015E00 +l0000000000015E00: + Mem206[&qwLocC0:byte] = 0xC0<8> + Mem208[&qwLocC0 + 1:byte] = 0xA8<8> +l0000000000015DBC: + Mem210[&qwLocC0:byte] = 0xAC<8> + Mem215[&qwLocC0 + 1:byte] = SLICE(qwLoc0190 >> 4, byte, 0) & 0xF<8> | 0x10<8> +l0000000000015C7C: + Mem218[&qwLocC0:byte] = 0xA<8> +l0000000000015C84: + Mem230[&qwLoc01A8:word32] = Mem220[&qwLocC0:int32] + branch inet_ntop(2, &qwLoc01A8, &bLocB8, 64) != 0<64> l00000000000154DC l0000000000015498: - a4 = Mem0[sp + 48:word64] - a1 = 15 - a0 = sp + 57 - a4 = a4 & 1 - a4 = a4 | -4 - Mem0[sp + 56:byte] = SLICE(a4, byte, 0) - call fn00000000000164D0 (retsize: 0;) - a5 = Mem0[sp + 8:word64] - branch a0 < 0<64> l0000000000015CB0 - // succ: l00000000000154BC l0000000000015CB0 + Mem238[&tLoc0188:byte] = SLICE(qwLoc0190, byte, 0) & 1<8> | 0xFC<8> + branch fn00000000000164D0(&tLoc0188 + 1, 15) < 0<64> l0000000000015CB0 l00000000000154BC: - s1 = sp + 264 - a3 = 64 - a2 = s1 - a1 = sp + 56 - a0 = 10 - a0 = inet_ntop(SLICE(a0, int32, 0), a1, a2, SLICE(a3, socklen_t, 0)) - a5 = Mem0[sp + 8:word64] - branch a0 == 0<64> l0000000000015CB0 - // succ: l00000000000154DC l0000000000015CB0 + branch inet_ntop(10, &tLoc0188, &bLocB8, 64) == 0<64> l0000000000015CB0 l00000000000154DC: - a2 = 0x12000<64> - a4 = a5 - a3 = s1 - a2 = a2 + -1392 - a1 = 1 - a0 = sp + 32 - Mem0[sp + 8:word64] = a5 - a0 = SEQ(0<32>, __asprintf_chk(a0, SLICE(a1, int32, 0), a2, a3, SLICE(a4, uint32, 0))) - a4 = -1 - a5 = Mem0[sp + 8:word64] - branch a0 == a4 l0000000000015CB0 - // succ: l0000000000015508 l0000000000015CB0 + a5_262 = a0_170 + branch CONVERT(__asprintf_chk(&ptrLoc01A0, 1, 0x11A90<64>, &bLocB8, SLICE(a0_170, uint32, 0)), uint32, uint64) == -1 l0000000000015CB0 l0000000000015508: - s1 = Mem0[sp + 32:word64] - branch s1 == 0<64> l0000000000015CB0 - // succ: l0000000000015510 l0000000000015CB0 + s1_144 = Mem259[&ptrLoc01A0:word64] + branch s1_144 == 0<64> l0000000000015CB0 +l0000000000015CB0: + branch CONVERT(Mem268[gp + -2028:int32], int32, int64) != 0<64> l00000000000153D8 +l0000000000015CB8: + __fprintf_chk(Mem268[gp + -1920:word64], 1, 0x11A98<64>, SLICE(a0_170, uint32, 0)) +l00000000000153CC: + branch true l00000000000155A8 +l00000000000155A8: + branch CONVERT(Mem97[&qwLoc01A8 + 4:int32], int32, int64) != 0<64> l0000000000015944 +l0000000000015944: + a0_289 = fn00000000000169D8(gp, 10, 0) + s1_144 = a0_289 + s0_131 = s2_125 + a5_262 = a0_61 + branch a0_289 != 0<64> l0000000000015510 l0000000000015510: - a4 = CONVERT(Mem0[sp:int32], int32, int64) - branch a4 != 0<64> l00000000000155D8 - // succ: l0000000000015518 l00000000000155D8 + branch false l00000000000155D8 +l00000000000155B0: + branch true l000000000001598C +l000000000001598C: + a0_306 = fn00000000000169D8(gp, 0, 0) + s1_144 = a0_306 + branch a0_306 == 0<64> l0000000000015964 +l00000000000159A4: + s0_131 = s2_125 + a5_262 = a0_61 l0000000000015518: - a1 = 58 - a0 = s1 - Mem0[sp:word64] = a5 - a0 = strchr(a0, SLICE(a1, char, 0)) - a5 = Mem0[sp:word64] - branch a0 == 0<64> l00000000000155D8 - // succ: l0000000000015530 l00000000000155D8 + branch strchr(s1_144, ':') == 0<64> l00000000000155D8 l0000000000015530: - a4 = 1 - Mem0[sp + 28:word32] = SLICE(a4, word32, 0) - branch s4 == 0<64> l0000000000015BEC - // succ: l000000000001553C l0000000000015BEC -l000000000001553C: - a5 = CONVERT(Mem0[gp + -2028:int32], int32, int64) - branch a5 != 0<64> l00000000000153D8 - // succ: l0000000000015544 l00000000000153D8 -l0000000000015544: - a0 = Mem0[gp + -1920:word64] - a2 = 0x12000<64> - a3 = s4 - a2 = a2 + -1328 - a1 = 1 - a0 = SEQ(0<32>, __fprintf_chk(a0, SLICE(a1, int32, 0), a2, a3)) - a0 = 1 - call fn0000000000015FCC (retsize: 0;) - s6 = 1 - goto l00000000000153DC - // succ: l00000000000153DC -l000000000001556C: - a3 = Mem0[gp + -1920:word64] - a0 = 0x12000<64> - a2 = 37 - a1 = 1 - a0 = a0 + -1528 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - goto l00000000000153D8 - // succ: l00000000000153D8 -l0000000000015588: - a2 = 0x12000<64> - a1 = 0x12000<64> - a2 = a2 + -1600 - a1 = a1 + -1592 - a0 = 1 - a0 = SEQ(0<32>, __printf_chk(SLICE(a0, int32, 0), a1, a2)) - s6 = 0 - goto l00000000000153DC - // succ: l00000000000153DC -l00000000000155A8: - a4 = CONVERT(Mem0[sp + 28:int32], int32, int64) - branch a4 != 0<64> l0000000000015944 - // succ: l00000000000155B0 l0000000000015944 -l00000000000155B0: - a4 = CONVERT(Mem0[sp:int32], int32, int64) - branch a4 == 0<64> l000000000001598C - // succ: l00000000000155B8 l000000000001598C + Mem327[&qwLoc01A8 + 4:word32] = 1<32> + branch s4_333 == 0<64> l0000000000015BEC +l0000000000015BEC: + a0_341 = strchr(s1_144, '/') + a5_342 = a5_262 + branch a0_341 != 0<64> l0000000000015BB8 +l0000000000015C04: l00000000000155B8: - a1 = s9 - a0 = 2 - Mem0[sp:word64] = a5 - call fn00000000000169D8 (retsize: 0;) - s1 = a0 - branch a0 == 0<64> l0000000000015964 - // succ: l00000000000155D0 l0000000000015964 + a0_346 = fn00000000000169D8(gp, 2, 0) + s1_144 = a0_346 + branch a0_346 == 0<64> l0000000000015964 +l0000000000015964: + branch CONVERT(Mem354[gp + -2028:int32], int32, int64) != 0<64> l00000000000153D8 +l000000000001596C: + __fprintf_chk(Mem354[gp + -1920:word64], 1, 0x11A50<64>, 0) l00000000000155D0: - a5 = Mem0[sp:word64] - s0 = s2 - // succ: l00000000000155D8 + a5_262 = a0_61 + s0_131 = s2_125 l00000000000155D8: - branch s4 == 0<64> l0000000000015BA0 - // succ: l00000000000155DC l0000000000015BA0 + branch s4_333 == 0<64> l0000000000015BA0 +l0000000000015BA0: + a0_341 = strchr(s1_144, '/') + a5_342 = a5_262 + branch a0_341 == 0<64> l00000000000155FC +l0000000000015BB8: + Mem376[a0_341:byte] = 0<8> + s4_333 = a0_341 + 1 + branch s4_333 == 0<64> l00000000000155FC +l0000000000015BC4: l00000000000155DC: - a5 = CONVERT(Mem0[sp + 28:int32], int32, int64) - branch a5 != 0<64> l000000000001553C - // succ: l00000000000155E4 l000000000001553C + branch CONVERT(Mem378[&qwLoc01A8 + 4:int32], int32, int64) != 0<64> l000000000001553C +l000000000001553C: + branch CONVERT(Mem384[gp + -2028:int32], int32, int64) != 0<64> l00000000000153D8 +l0000000000015544: + __fprintf_chk(Mem384[gp + -1920:word64], 1, 0x11AD0<64>, s4_333) + fn0000000000015FCC(gp, 1) l00000000000155E4: - a2 = 0 - a1 = s4 - a0 = sp + 28 - call fn00000000000166F4 (retsize: 0;) - a5 = a0 - branch a0 < 0<64> l0000000000015B6C - // succ: l00000000000155FC l0000000000015B6C + a0_409 = fn00000000000166F4(gp, &qwLoc01A8 + 4, s4_333, 0) + a5_342 = a0_409 + branch a0_409 < 0<64> l0000000000015B6C +l0000000000015B6C: + branch CONVERT(Mem416[gp + -2028:int32], int32, int64) != 0<64> l00000000000153D8 +l0000000000015B74: + a0_179 = Mem416[gp + -1920:word64] + branch CONVERT(Mem416[&qwLoc01A8 + 4:int32], int32, int64) != 0<64> l0000000000015CD8 +l0000000000015CD8: + a3_181 = 0x11998<64> +l0000000000015B80: + a3_181 = 0x119A0<64> +l0000000000015B88: + a4_182 = s4_333 +l0000000000015B8C: + __fprintf_chk(a0_179, 1, 0x11A70<64>, a3_181, a4_182) l00000000000155FC: - a4 = CONVERT(Mem0[sp + 28:int32], int32, int64) - branch a4 == 0<64> l00000000000159B0 - // succ: l0000000000015604 l00000000000159B0 + branch CONVERT(Mem436[&qwLoc01A8 + 4:int32], int32, int64) == 0<64> l00000000000159B0 +l00000000000159B0: + a0_473 = fn0000000000016D74(ra, gp, s1_144, a5_342, &tLoc0188, s0_131, out a4_476) l0000000000015604: - a3 = s0 - a2 = sp + 56 - a1 = a5 - a0 = s1 - call fn00000000000175BC (retsize: 0;) - // succ: l0000000000015618 + a0_473 = fn00000000000175BC(ra, gp, s1_144, s1_144, a5_342, &tLoc0188, s0_131, out a4_476) l0000000000015618: - branch a0 < 0<64> l00000000000153D8 - // succ: l000000000001561C l00000000000153D8 + branch a0_473 < 0<64> l00000000000153D8 l000000000001561C: - a5 = 0xFFFAC000<64> - v34 = SLICE(a5, word32, 0) - a5 = CONVERT(v34 - 1, word32, int64) - a5 = s0 & a5 - branch a5 != 0<64> l0000000000015630 - // succ: l000000000001562C l0000000000015630 + branch (s0_131 & 4294623231) != 0<64> l0000000000015630 l000000000001562C: - s0 = s0 | 8 - // succ: l0000000000015630 + s0_131 = s0_131 | 8 l0000000000015630: - a0 = 1 - a0 = SEQ(0<32>, isatty(SLICE(a0, int32, 0))) - branch a0 == 0<64> l0000000000015644 - // succ: l000000000001563C l0000000000015644 + branch CONVERT(isatty(1), uint32, uint64) == 0<64> l0000000000015644 l000000000001563C: - a4 = 1 - Mem0[gp + -2032:word32] = SLICE(a4, word32, 0) - // succ: l0000000000015644 + Mem505[gp + -2032:word32] = 1<32> + a4_476 = 1 l0000000000015644: - a5 = s0 & 8 - branch a5 == 0<64> l00000000000159C8 - // succ: l000000000001564C l00000000000159C8 -l000000000001564C: - a5 = CONVERT(Mem0[sp + 28:int32], int32, int64) - s2 = CONVERT(Mem0[sp + 216:int32], int32, int64) - branch a5 != 0<64> l000000000001590C - // succ: l0000000000015658 l000000000001590C -l0000000000015658: - a5 = 32 - branch s2 == a5 l0000000000015914 - // succ: l0000000000015660 l0000000000015914 -l0000000000015660: - branch s10 == 0<64> l0000000000015860 - // succ: l0000000000015664 l0000000000015860 -l0000000000015664: - s1 = 0x12000<64> - // succ: l0000000000015668 -l0000000000015668: - a3 = Mem0[sp + 72:word64] - s3 = 0x12000<64> - branch a3 == 0<64> l0000000000015690 - // succ: l0000000000015674 l0000000000015690 -l0000000000015674: - a1 = 0x12000<64> - a4 = s2 - a2 = s3 + -1248 - a1 = a1 + -1240 - a0 = s1 + -1272 - call fn000000000001654C (retsize: 0;) - s2 = CONVERT(Mem0[sp + 216:int32], int32, int64) - // succ: l0000000000015690 -l0000000000015690: - a3 = Mem0[sp + 88:word64] - a1 = 0x12000<64> - a4 = s2 - a2 = s3 + -1248 - a1 = a1 + -1224 - a0 = s1 + -1272 - call fn000000000001654C (retsize: 0;) - a3 = Mem0[sp + 104:word64] - a4 = CONVERT(Mem0[sp + 216:int32], int32, int64) - a2 = 0x12000<64> - a1 = 0x12000<64> - a2 = a2 + -1208 - a1 = a1 + -1192 - a0 = s1 + -1272 - call fn000000000001654C (retsize: 0;) - a3 = Mem0[sp + 96:word64] - branch a3 == 0<64> l00000000000156EC - // succ: l00000000000156D4 l00000000000156EC -l00000000000156D4: - s2 = 0x12000<64> - a1 = 0x12000<64> - a2 = s2 + -928 - a1 = a1 + -1176 - a0 = s1 + -1272 - call fn000000000001654C (retsize: 0;) - // succ: l00000000000156EC -l00000000000156EC: - a5 = 0x10000<64> - v36 = SLICE(a5, word32, 0) - a5 = CONVERT(v36 + 8, word32, int64) - s0 = s0 & a5 - branch s0 == a5 l0000000000015C1C - // succ: l00000000000156FC l0000000000015C1C -l00000000000156FC: - a0 = 10 - a0 = SEQ(0<32>, putchar(SLICE(a0, int32, 0))) - a3 = Mem0[sp + 240:word64] - branch a3 == 0<64> l0000000000015728 - // succ: l000000000001570C l0000000000015728 -l000000000001570C: - a2 = 0x12000<64> - a1 = 0x12000<64> - a0 = 0x12000<64> - a2 = a2 + -928 - a1 = a1 + -1144 - a0 = a0 + -1128 - call fn000000000001654C (retsize: 0;) - // succ: l0000000000015728 -l0000000000015728: - a3 = Mem0[sp + 248:word64] - branch a3 == 0<64> l000000000001574C - // succ: l0000000000015730 l000000000001574C -l0000000000015730: - a2 = 0x12000<64> - a1 = 0x12000<64> - a0 = 0x12000<64> - a2 = a2 + -928 - a1 = a1 + -1120 - a0 = a0 + -1128 - call fn000000000001654C (retsize: 0;) - // succ: l000000000001574C -l000000000001574C: - a3 = Mem0[sp + 224:word64] - branch a3 == 0<64> l000000000001576C - // succ: l0000000000015754 l000000000001576C -l0000000000015754: - a2 = 0x12000<64> - a1 = 0x12000<64> - a2 = a2 + -928 - a1 = a1 + -1104 - a0 = s1 + -1272 - call fn000000000001654C (retsize: 0;) - // succ: l000000000001576C -l000000000001576C: - a3 = Mem0[sp + 232:word64] - branch a3 == 0<64> l000000000001578C - // succ: l0000000000015774 l000000000001578C -l0000000000015774: - a2 = 0x12000<64> - a1 = 0x12000<64> - a2 = a2 + -928 - a1 = a1 + -1088 - a0 = s1 + -1272 - call fn000000000001654C (retsize: 0;) - // succ: l000000000001578C -l000000000001578C: - a5 = CONVERT(Mem0[sp + 28:int32], int32, int64) - branch a5 == 0<64> l00000000000157A0 - // succ: l0000000000015794 l00000000000157A0 -l0000000000015794: - a5 = CONVERT(Mem0[sp + 216:int32], int32, int64) - a4 = 111 - branch a4 >=u a5 l0000000000015E3C - // succ: l00000000000157A0 l0000000000015E3C -l00000000000157A0: - a2 = 0x12000<64> - a1 = 0x12000<64> - a3 = sp + 152 - a2 = a2 + -928 - a1 = a1 + -1056 - a0 = s1 + -1272 - call fn000000000001654C (retsize: 0;) - // succ: l00000000000157BC -l00000000000157BC: - a5 = Mem0[sp + 120:word64] - branch a5 == 0<64> l0000000000015C08 - // succ: l00000000000157C4 l0000000000015C08 -l00000000000157C4: - a0 = 10 - a0 = SEQ(0<32>, putchar(SLICE(a0, int32, 0))) - a3 = Mem0[sp + 128:word64] - branch a3 == 0<64> l00000000000157F0 - // succ: l00000000000157D4 l00000000000157F0 -l00000000000157D4: - a2 = 0x12000<64> - a1 = 0x12000<64> - a0 = 0x12000<64> - a2 = a2 + -928 - a1 = a1 + -1040 - a0 = a0 + -1128 - call fn000000000001654C (retsize: 0;) - // succ: l00000000000157F0 -l00000000000157F0: - a3 = Mem0[sp + 120:word64] - branch a3 == 0<64> l0000000000015814 - // succ: l00000000000157F8 l0000000000015814 -l00000000000157F8: - a2 = 0x12000<64> - a1 = 0x12000<64> - a0 = 0x12000<64> - a2 = a2 + -928 - a1 = a1 + -1024 - a0 = a0 + -1128 - call fn000000000001654C (retsize: 0;) - // succ: l0000000000015814 -l0000000000015814: - a3 = Mem0[sp + 136:word64] - branch a3 == 0<64> l0000000000015838 - // succ: l000000000001581C l0000000000015838 -l000000000001581C: - a2 = 0x12000<64> - a1 = 0x12000<64> - a0 = 0x12000<64> - a2 = a2 + -928 - a1 = a1 + -1008 - a0 = a0 + -1128 - call fn000000000001654C (retsize: 0;) - // succ: l0000000000015838 -l0000000000015838: - a3 = Mem0[sp + 144:word64] - branch a3 == 0<64> l00000000000153DC - // succ: l0000000000015840 l00000000000153DC -l0000000000015840: - a2 = 0x12000<64> - a1 = 0x12000<64> - a0 = 0x12000<64> - a2 = a2 + -928 - a1 = a1 + -1000 - a0 = a0 + -1128 - call fn000000000001654C (retsize: 0;) - goto l00000000000153DC - // succ: l00000000000153DC -l0000000000015860: - s3 = Mem0[sp + 56:word64] - a0 = Mem0[sp + 88:word64] - a1 = s3 - a0 = SEQ(0<32>, strcmp(a0, a1)) - branch a0 == 0<64> l0000000000015664 - // succ: l0000000000015874 l0000000000015664 -l0000000000015874: - a3 = Mem0[sp + 64:word64] - s4 = 0 - branch a3 == 0<64> l0000000000015E14 - // succ: l0000000000015880 l0000000000015E14 -l0000000000015880: - s2 = 0x12000<64> - s1 = 0x12000<64> - a1 = 0x12000<64> - a2 = s2 + -928 - a1 = a1 + -1288 - a0 = s1 + -1272 - call fn000000000001654C (retsize: 0;) - a3 = Mem0[sp + 56:word64] - a1 = 0x12000<64> - a2 = s2 + -928 - a1 = a1 + -1264 - a0 = s1 + -1272 - call fn000000000001654C (retsize: 0;) - branch s4 == 0<64> l0000000000015E74 - // succ: l00000000000158B8 l0000000000015E74 -l00000000000158B8: - a5 = 0x10000<64> - v35 = SLICE(a5, word32, 0) - a5 = CONVERT(v35 + 8, word32, int64) - s0 = s0 & a5 - branch s0 == a5 l0000000000015E64 - // succ: l00000000000158C8 l0000000000015E64 -l00000000000158C8: - a3 = Mem0[sp + 240:word64] - branch a3 == 0<64> l00000000000158E8 - // succ: l00000000000158D0 l00000000000158E8 -l00000000000158D0: - a1 = 0x12000<64> - a0 = 0x12000<64> - a2 = s2 + -928 - a1 = a1 + -1144 - a0 = a0 + -1128 - call fn000000000001654C (retsize: 0;) - // succ: l00000000000158E8 -l00000000000158E8: - a3 = Mem0[sp + 248:word64] - branch a3 == 0<64> l00000000000157BC - // succ: l00000000000158F0 l00000000000157BC -l00000000000158F0: - a1 = 0x12000<64> - a0 = 0x12000<64> - a2 = s2 + -928 - a1 = a1 + -1120 - a0 = a0 + -1128 - call fn000000000001654C (retsize: 0;) - goto l00000000000157BC - // succ: l00000000000157BC -l000000000001590C: - a5 = 128 - branch s2 != a5 l0000000000015660 - // succ: l0000000000015914 l0000000000015660 -l0000000000015914: - a3 = Mem0[sp + 64:word64] - branch a3 == 0<64> l0000000000015DDC - // succ: l000000000001591C l0000000000015DDC -l000000000001591C: - s4 = 1 - goto l0000000000015880 - // succ: l0000000000015880 -l0000000000015924: - call fn0000000000017924 (retsize: 0;) - a5 = Mem0[sp + 8:word64] - branch a0 != 0<64> l0000000000015458 - // succ: l0000000000015930 l0000000000015458 -l0000000000015930: - a4 = 0x10000<64> - v32 = SLICE(a4, word32, 0) - a4 = CONVERT(v32 + 8, word32, int64) - a3 = s0 & a4 - branch a3 != a4 l0000000000015458 - // succ: l0000000000015940 l0000000000015458 -l0000000000015940: - goto l0000000000015448 - // succ: l0000000000015448 -l0000000000015944: - a1 = s9 - a0 = 10 - Mem0[sp + 8:word64] = a5 - call fn00000000000169D8 (retsize: 0;) - s1 = a0 - s0 = s2 - a5 = Mem0[sp + 8:word64] - branch a0 != 0<64> l0000000000015510 - // succ: l0000000000015964 l0000000000015510 -l0000000000015964: - a5 = CONVERT(Mem0[gp + -2028:int32], int32, int64) - branch a5 != 0<64> l00000000000153D8 - // succ: l000000000001596C l00000000000153D8 -l000000000001596C: - a0 = Mem0[gp + -1920:word64] - a2 = 0x12000<64> - a3 = s9 - a2 = a2 + -1456 - a1 = 1 - a0 = SEQ(0<32>, __fprintf_chk(a0, SLICE(a1, int32, 0), a2, a3)) - s6 = 1 - goto l00000000000153DC - // succ: l00000000000153DC -l000000000001598C: - a1 = s9 - a0 = 0 - Mem0[sp:word64] = a5 - call fn00000000000169D8 (retsize: 0;) - s1 = a0 - branch a0 == 0<64> l0000000000015964 - // succ: l00000000000159A4 l0000000000015964 -l00000000000159A4: - s0 = s2 - a5 = Mem0[sp:word64] - goto l0000000000015518 - // succ: l0000000000015518 -l00000000000159B0: - a3 = s0 - a2 = sp + 56 - a1 = a5 - a0 = s1 - call fn0000000000016D74 (retsize: 0;) - goto l0000000000015618 - // succ: l0000000000015618 + branch (s0_131 & 8) == 0<64> l00000000000159C8 l00000000000159C8: - a5 = s0 & 128 - branch a5 != 0<64> l0000000000015D18 - // succ: l00000000000159D0 l0000000000015D18 + branch (s0_131 & 128) != 0<64> l0000000000015D18 +l0000000000015D18: + __printf_chk(1, 0x11C28<64>, Mem513[&tLoc0188 + 48:word64]) l00000000000159D0: - a5 = s0 & 512 - branch a5 != 0<64> l0000000000015D48 - // succ: l00000000000159D8 l0000000000015D48 + branch (s0_131 & 512) != 0<64> l0000000000015D48 +l0000000000015D48: + __printf_chk(1, 0x11C38<64>, Mem513[&tLoc0188 + 160:int32]) l00000000000159D8: - a5 = s0 & 64 - branch a5 == 0<64> l00000000000159FC - // succ: l00000000000159E0 l00000000000159FC + branch (s0_131 & 64) == 0<64> l00000000000159FC l00000000000159E0: - a5 = CONVERT(Mem0[sp + 28:int32], int32, int64) - branch a5 != 0<64> l00000000000159FC - // succ: l00000000000159E8 l00000000000159FC + branch CONVERT(Mem513[&qwLoc01A8 + 4:int32], int32, int64) != 0<64> l00000000000159FC l00000000000159E8: - a2 = Mem0[sp + 96:word64] - a1 = 0x12000<64> - a1 = a1 + -952 - a0 = 1 - a0 = SEQ(0<32>, __printf_chk(SLICE(a0, int32, 0), a1, a2)) - // succ: l00000000000159FC + __printf_chk(1, 0x11C48<64>, Mem513[&tLoc0188 + 40:word64]) l00000000000159FC: - a5 = s0 & 256 - branch a5 != 0<64> l0000000000015D30 - // succ: l0000000000015A04 l0000000000015D30 + branch (s0_131 & 256) != 0<64> l0000000000015D30 +l0000000000015D30: + __printf_chk(1, 0x11C58<64>, Mem513[&tLoc0188 + 32:word64]) l0000000000015A04: - a5 = s0 << 0x2E - branch a5 < 0<64> l0000000000015D78 - // succ: l0000000000015A0C l0000000000015D78 + branch s0_131 << 0x2E < 0<64> l0000000000015D78 +l0000000000015D78: + __printf_chk(1, 0x11C68<64>, Mem513[&tLoc0188 + 24:word64]) l0000000000015A0C: - a5 = s0 & 1024 - branch a5 == 0<64> l0000000000015A2C - // succ: l0000000000015A14 l0000000000015A2C + branch (s0_131 & 1024) == 0<64> l0000000000015A2C l0000000000015A14: - a2 = Mem0[sp + 224:word64] - branch a2 == 0<64> l0000000000015A2C - // succ: l0000000000015A1C l0000000000015A2C + a2_563 = Mem513[&tLoc0188 + 168:word64] + branch a2_563 == 0<64> l0000000000015A2C l0000000000015A1C: - a1 = 0x12000<64> - a1 = a1 + -904 - a0 = 1 - a0 = SEQ(0<32>, __printf_chk(SLICE(a0, int32, 0), a1, a2)) - // succ: l0000000000015A2C + __printf_chk(1, 0x11C78<64>, a2_563) l0000000000015A2C: - a5 = s0 << 0x34 - branch a5 >= 0<64> l0000000000015A4C - // succ: l0000000000015A34 l0000000000015A4C + branch s0_131 << 0x34 >= 0<64> l0000000000015A4C l0000000000015A34: - a2 = Mem0[sp + 232:word64] - branch a2 == 0<64> l0000000000015A4C - // succ: l0000000000015A3C l0000000000015A4C + a2_572 = Mem513[&tLoc0188 + 176:word64] + branch a2_572 == 0<64> l0000000000015A4C l0000000000015A3C: - a1 = 0x12000<64> - a1 = a1 + -888 - a0 = 1 - a0 = SEQ(0<32>, __printf_chk(SLICE(a0, int32, 0), a1, a2)) - // succ: l0000000000015A4C + __printf_chk(1, 0x11C88<64>, a2_572) l0000000000015A4C: - a5 = s0 << 0x32 - branch a5 >= 0<64> l0000000000015A80 - // succ: l0000000000015A54 l0000000000015A80 + branch s0_131 << 0x32 >= 0<64> l0000000000015A80 l0000000000015A54: - s2 = Mem0[sp + 240:word64] - branch s2 == 0<64> l0000000000015A80 - // succ: l0000000000015A5C l0000000000015A80 + s2_581 = Mem513[&tLoc0188 + 184:word64] + branch s2_581 == 0<64> l0000000000015A80 l0000000000015A5C: - a1 = 32 - a0 = s2 - a0 = strchr(a0, SLICE(a1, char, 0)) - a2 = s2 - branch a0 == 0<64> l0000000000015DA4 - // succ: l0000000000015A70 l0000000000015DA4 + branch strchr(s2_581, ' ') == 0<64> l0000000000015DA4 +l0000000000015DA4: + __printf_chk(1, 0x11CA8<64>, s2_581) l0000000000015A70: - a1 = 0x12000<64> - a1 = a1 + -872 - a0 = 1 - a0 = SEQ(0<32>, __printf_chk(SLICE(a0, int32, 0), a1, a2)) - // succ: l0000000000015A80 + __printf_chk(1, 0x11C98<64>, s2_581) l0000000000015A80: - a5 = s0 << 0x33 - branch a5 >= 0<64> l0000000000015AAC - // succ: l0000000000015A88 l0000000000015AAC + branch s0_131 << 0x33 >= 0<64> l0000000000015AAC l0000000000015A88: - a1 = 32 - a0 = sp + 152 - a0 = strchr(a0, SLICE(a1, char, 0)) - a2 = sp + 152 - branch a0 == 0<64> l0000000000015D90 - // succ: l0000000000015A9C l0000000000015D90 + branch strchr(&tLoc0188 + 96, ' ') == 0<64> l0000000000015D90 +l0000000000015D90: + __printf_chk(1, 0x11CC8<64>, &tLoc0188 + 96) l0000000000015A9C: - a1 = 0x12000<64> - a1 = a1 + -840 - a0 = 1 - a0 = SEQ(0<32>, __printf_chk(SLICE(a0, int32, 0), a1, a2)) - // succ: l0000000000015AAC + __printf_chk(1, 0x11CB8<64>, &tLoc0188 + 96) l0000000000015AAC: - a5 = s0 & 1 - branch a5 == 0<64> l0000000000015ACC - // succ: l0000000000015AB4 l0000000000015ACC + branch (s0_131 & 1) == 0<64> l0000000000015ACC l0000000000015AB4: - a2 = Mem0[sp + 112:word64] - branch a2 == 0<64> l0000000000015ACC - // succ: l0000000000015ABC l0000000000015ACC + a2_614 = Mem513[&tLoc0188 + 56:word64] + branch a2_614 == 0<64> l0000000000015ACC l0000000000015ABC: - a1 = 0x12000<64> - a1 = a1 + -808 - a0 = 1 - a0 = SEQ(0<32>, __printf_chk(SLICE(a0, int32, 0), a1, a2)) - // succ: l0000000000015ACC + __printf_chk(1, 0x11CD8<64>, a2_614) l0000000000015ACC: - a5 = s0 & 2 - branch a5 != 0<64> l0000000000015D60 - // succ: l0000000000015AD4 l0000000000015D60 + branch (s0_131 & 2) != 0<64> l0000000000015D60 +l0000000000015D60: + __printf_chk(1, 0x11CE8<64>, s1_144) l0000000000015AD4: - a5 = 0xC000<64> - s0 = s0 & a5 - branch s0 != a5 l00000000000153DC - // succ: l0000000000015AE0 l00000000000153DC + branch (s0_131 & 0xC000<64>) != 0xC000<64> l00000000000153DC l0000000000015AE0: - a2 = Mem0[sp + 128:word64] - branch a2 == 0<64> l0000000000015AF8 - // succ: l0000000000015AE8 l0000000000015AF8 + a2_646 = Mem513[&tLoc0188 + 72:word64] + branch a2_646 == 0<64> l0000000000015AF8 l0000000000015AE8: - a1 = 0x12000<64> - a1 = a1 + -776 - a0 = 1 - a0 = SEQ(0<32>, __printf_chk(SLICE(a0, int32, 0), a1, a2)) - // succ: l0000000000015AF8 + __printf_chk(1, 0x11CF8<64>, a2_646) l0000000000015AF8: - s0 = Mem0[sp + 120:word64] - branch s0 == 0<64> l0000000000015B24 - // succ: l0000000000015B00 l0000000000015B24 + s0_653 = Mem513[&tLoc0188 + 64:word64] + branch s0_653 == 0<64> l0000000000015B24 l0000000000015B00: - a1 = 32 - a0 = s0 - a0 = strchr(a0, SLICE(a1, char, 0)) - a2 = s0 - branch a0 == 0<64> l0000000000015E90 - // succ: l0000000000015B14 l0000000000015E90 + branch strchr(s0_653, ' ') == 0<64> l0000000000015E90 +l0000000000015E90: + __printf_chk(1, 0x11D18<64>, s0_653) l0000000000015B14: - a1 = 0x12000<64> - a1 = a1 + -760 - a0 = 1 - a0 = SEQ(0<32>, __printf_chk(SLICE(a0, int32, 0), a1, a2)) - // succ: l0000000000015B24 + __printf_chk(1, 0x11D08<64>, s0_653) l0000000000015B24: - s0 = Mem0[sp + 136:word64] - branch s0 == 0<64> l0000000000015B50 - // succ: l0000000000015B2C l0000000000015B50 + s0_668 = Mem513[&tLoc0188 + 80:word64] + branch s0_668 == 0<64> l0000000000015B50 l0000000000015B2C: - a1 = 32 - a0 = s0 - a0 = strchr(a0, SLICE(a1, char, 0)) - a2 = s0 - branch a0 == 0<64> l0000000000015EA4 - // succ: l0000000000015B40 l0000000000015EA4 + branch strchr(s0_668, ' ') == 0<64> l0000000000015EA4 +l0000000000015EA4: + __printf_chk(1, 0x11D38<64>, s0_668) l0000000000015B40: - a1 = 0x12000<64> - a1 = a1 + -728 - a0 = 1 - a0 = SEQ(0<32>, __printf_chk(SLICE(a0, int32, 0), a1, a2)) - // succ: l0000000000015B50 + __printf_chk(1, 0x11D28<64>, s0_668) l0000000000015B50: - a2 = Mem0[sp + 144:word64] - branch a2 == 0<64> l00000000000153DC - // succ: l0000000000015B58 l00000000000153DC + a2_683 = Mem513[&tLoc0188 + 88:word64] + branch a2_683 == 0<64> l00000000000153DC l0000000000015B58: - a1 = 0x12000<64> - a1 = a1 + -696 - a0 = 1 - a0 = SEQ(0<32>, __printf_chk(SLICE(a0, int32, 0), a1, a2)) - goto l00000000000153DC - // succ: l00000000000153DC -l0000000000015B6C: - a5 = CONVERT(Mem0[gp + -2028:int32], int32, int64) - branch a5 != 0<64> l00000000000153D8 - // succ: l0000000000015B74 l00000000000153D8 -l0000000000015B74: - a5 = CONVERT(Mem0[sp + 28:int32], int32, int64) - a0 = Mem0[gp + -1920:word64] - branch a5 != 0<64> l0000000000015CD8 - // succ: l0000000000015B80 l0000000000015CD8 -l0000000000015B80: - a3 = 0x12000<64> - a3 = a3 + -1632 - // succ: l0000000000015B88 -l0000000000015B88: - a4 = s4 - // succ: l0000000000015B8C -l0000000000015B8C: - a2 = 0x12000<64> - a2 = a2 + -1424 - a1 = 1 - a0 = SEQ(0<32>, __fprintf_chk(a0, SLICE(a1, int32, 0), a2, a3, a4)) - goto l00000000000153D8 - // succ: l00000000000153D8 -l0000000000015BA0: - a1 = 47 - a0 = s1 - Mem0[sp:word64] = a5 - a0 = strchr(a0, SLICE(a1, char, 0)) - a5 = Mem0[sp:word64] - branch a0 == 0<64> l00000000000155FC - // succ: l0000000000015BB8 l00000000000155FC -l0000000000015BB8: - Mem0[a0:byte] = SLICE(0<64>, byte, 0) - s4 = a0 + 1 - branch s4 == 0<64> l00000000000155FC - // succ: l0000000000015BC4 l00000000000155FC -l0000000000015BC4: - goto l00000000000155E4 - // succ: l00000000000155E4 -l0000000000015BC8: - a5 = CONVERT(Mem0[gp + -2028:int32], int32, int64) - branch a5 != 0<64> l00000000000153D8 - // succ: l0000000000015BD0 l00000000000153D8 -l0000000000015BD0: - a5 = CONVERT(Mem0[sp + 28:int32], int32, int64) - a0 = Mem0[gp + -1920:word64] - branch a5 != 0<64> l0000000000015E7C - // succ: l0000000000015BDC l0000000000015E7C -l0000000000015BDC: - a3 = 0x12000<64> - a3 = a3 + -1632 - a4 = s10 - goto l0000000000015B8C - // succ: l0000000000015B8C -l0000000000015BEC: - a1 = 47 - a0 = s1 - Mem0[sp:word64] = a5 - a0 = strchr(a0, SLICE(a1, char, 0)) - a5 = Mem0[sp:word64] - branch a0 != 0<64> l0000000000015BB8 - // succ: l0000000000015C04 l0000000000015BB8 -l0000000000015C04: - goto l0000000000015604 - // succ: l0000000000015604 -l0000000000015C08: - a5 = Mem0[sp + 136:word64] - branch a5 != 0<64> l00000000000157C4 - // succ: l0000000000015C10 l00000000000157C4 -l0000000000015C10: - a5 = Mem0[sp + 144:word64] - branch a5 != 0<64> l00000000000157C4 - // succ: l0000000000015C18 l00000000000157C4 -l0000000000015C18: - goto l00000000000153DC - // succ: l00000000000153DC + __printf_chk(1, 0x11D48<64>, a2_683) +l000000000001564C: + s2_689 = CONVERT(Mem513[&tLoc0188 + 160:int32], int32, int64) + branch CONVERT(Mem513[&qwLoc01A8 + 4:int32], int32, int64) != 0<64> l000000000001590C +l000000000001590C: + a5_690 = 128 + branch s2_689 != 128 l0000000000015660 +l0000000000015658: + a5_690 = 32 + branch s2_689 == 32 l0000000000015914 +l0000000000015914: + a3_694 = Mem513[&tLoc0188 + 8:word64] + branch a3_694 == 0<64> l0000000000015DDC +l0000000000015DDC: + gp = fn000000000001654C(gp, Mem513[&tLoc0188:word64], a4_476, a5_690, a6_1018, a7, out a4_1016, out a5_2684, out a6_1018, out a7) +l000000000001591C: + s4_757 = 1 +l0000000000015660: + branch true l0000000000015860 +l0000000000015860: + s3_774 = Mem513[&tLoc0188:word64] + branch CONVERT(strcmp(Mem513[&tLoc0188 + 32:word64], s3_774), uint32, uint64) == 0<64> l0000000000015664 +l0000000000015874: + a3_694 = Mem513[&tLoc0188 + 8:word64] + s4_757 = 0 + branch a3_694 == 0<64> l0000000000015E14 +l0000000000015E14: + gp = fn000000000001654C(gp, s3_774, a4_476, a5_690, a6_1018, a7, out a4_2683, out a5_690, out a6_1018, out a7) + s2_689 = CONVERT(Mem513[&tLoc0188 + 160:int32], int32, int64) +l0000000000015880: + gp = fn000000000001654C(fn000000000001654C(gp, a3_694, a4_476, a5_690, a6_1018, a7, out a4_820, out a5_821, out a6_822, out a7_823), Mem513[&tLoc0188:word64], a4_820, a5_821, a6_822, a7_823, out a4_1016, out a5_690, out a6_1018, out a7) + branch s4_757 == 0<64> l0000000000015E74 +l0000000000015E74: + s2_689 = CONVERT(Mem513[&tLoc0188 + 160:int32], int32, int64) +l00000000000158B8: + a5_1017 = 65544 + branch (s0_131 & 65544) == 65544 l0000000000015E64 +l0000000000015E64: + a3_857 = Mem513[&tLoc0188 + 24:word64] + s0_1003 = 1 + branch a3_857 != 0<64> l0000000000015C2C +l0000000000015E70: +l0000000000015664: +l0000000000015668: + a3_864 = Mem513[&tLoc0188 + 16:word64] + branch a3_864 == 0<64> l0000000000015690 +l0000000000015674: + gp = fn000000000001654C(gp, a3_864, s2_689, a5_690, a6_1018, a7, out a4_2681, out a5_690, out a6_1018, out a7) + s2_689 = CONVERT(Mem513[&tLoc0188 + 160:int32], int32, int64) +l0000000000015690: + gp = fn000000000001654C(fn000000000001654C(gp, Mem513[&tLoc0188 + 32:word64], s2_689, a5_690, a6_1018, a7, out a4_2680, out a5_915, out a6_916, out a7_917), Mem513[&tLoc0188 + 48:word64], CONVERT(Mem513[&tLoc0188 + 160:int32], int32, int64), a5_915, a6_916, a7_917, out a4_1016, out a5_933, out a6_1018, out a7) + a3_939 = Mem513[&tLoc0188 + 40:word64] + branch a3_939 == 0<64> l00000000000156EC +l00000000000156D4: + gp = fn000000000001654C(gp, a3_939, a4_1016, a5_933, a6_1018, a7, out a4_1016, out a5_2682, out a6_1018, out a7) +l00000000000156EC: + a5_1017 = 65544 + branch (s0_131 & 65544) == 65544 l0000000000015C1C l0000000000015C1C: - a3 = Mem0[sp + 80:word64] - branch a3 == 0<64> l00000000000156FC - // succ: l0000000000015C24 l00000000000156FC + a3_857 = Mem513[&tLoc0188 + 24:word64] + branch a3_857 == 0<64> l00000000000156FC l0000000000015C24: - s0 = 0 - s2 = 0x12000<64> - // succ: l0000000000015C2C + s0_1003 = 0 l0000000000015C2C: - a1 = 0x12000<64> - a2 = s2 + -928 - a1 = a1 + -1160 - a0 = s1 + -1272 - call fn000000000001654C (retsize: 0;) - branch s0 != 0<64> l00000000000158C8 - // succ: l0000000000015C44 l00000000000158C8 + gp = fn000000000001654C(gp, a3_857, a4_1016, 65544, a6_1018, a7, out a4_1016, out a5_1017, out a6_1018, out a7) + branch s0_1003 != 0<64> l00000000000158C8 +l00000000000158C8: + a3_1008 = Mem513[&tLoc0188 + 184:word64] + branch a3_1008 == 0<64> l00000000000158E8 +l00000000000158D0: + gp = fn000000000001654C(gp, a3_1008, a4_1016, a5_1017, a6_1018, a7, out a4_1016, out a5_1017, out a6_1018, out a7) +l00000000000158E8: + a3_1033 = Mem513[&tLoc0188 + 192:word64] + branch a3_1033 == 0<64> l00000000000157BC +l00000000000158F0: + gp = fn000000000001654C(gp, a3_1033, a4_1016, a5_1017, a6_1018, a7, out a4_1016, out a5_2685, out a6_1018, out a7) l0000000000015C44: - goto l00000000000156FC - // succ: l00000000000156FC -l0000000000015C48: - a1 = 4 - a0 = sp + 256 - Mem0[sp + 8:word64] = a5 - s1 = Mem0[sp + 48:word64] - call fn00000000000164D0 (retsize: 0;) - a5 = Mem0[sp + 8:word64] - branch a0 < 0<64> l0000000000015CB0 - // succ: l0000000000015C64 l0000000000015CB0 -l0000000000015C64: - a4 = 15 - branch a4 >= a5 l0000000000015C7C - // succ: l0000000000015C6C l0000000000015C7C -l0000000000015C6C: - a4 = 4 - a4 = s1 %s a4 - a3 = 1 - branch a3 >=u a4 l0000000000015DB8 - // succ: l0000000000015C7C l0000000000015DB8 -l0000000000015C7C: - a4 = 10 - Mem0[sp + 256:byte] = SLICE(a4, byte, 0) - // succ: l0000000000015C84 -l0000000000015C84: - a4 = CONVERT(Mem0[sp + 256:int32], int32, int64) - s1 = sp + 264 - a3 = 64 - a2 = s1 - a1 = sp + 24 - a0 = 2 - Mem0[sp + 8:word64] = a5 - Mem0[sp + 24:word32] = SLICE(a4, word32, 0) - a0 = inet_ntop(SLICE(a0, int32, 0), a1, a2, SLICE(a3, socklen_t, 0)) - a5 = Mem0[sp + 8:word64] - branch a0 != 0<64> l00000000000154DC - // succ: l0000000000015CB0 l00000000000154DC -l0000000000015CB0: - a4 = CONVERT(Mem0[gp + -2028:int32], int32, int64) - branch a4 != 0<64> l00000000000153D8 - // succ: l0000000000015CB8 l00000000000153D8 -l0000000000015CB8: - a0 = Mem0[gp + -1920:word64] - a2 = 0x12000<64> - a3 = a5 - a2 = a2 + -1384 - a1 = 1 - a0 = SEQ(0<32>, __fprintf_chk(a0, SLICE(a1, int32, 0), a2, SLICE(a3, uint32, 0))) - s6 = 1 - goto l00000000000153DC - // succ: l00000000000153DC -l0000000000015CD8: - a3 = 0x12000<64> - a3 = a3 + -1640 - goto l0000000000015B88 - // succ: l0000000000015B88 -l0000000000015CE4: - branch s1 != 0<64> l0000000000015510 - // succ: l0000000000015CE8 l0000000000015510 -l0000000000015CE8: - a5 = CONVERT(Mem0[gp + -2028:int32], int32, int64) - branch a5 != 0<64> l00000000000153D8 - // succ: l0000000000015CF0 l00000000000153D8 -l0000000000015CF0: - a3 = Mem0[gp + -1920:word64] - a0 = 0x12000<64> - a2 = 28 - a1 = 1 - a0 = a0 + -1488 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a0 = 1 - call fn0000000000015FCC (retsize: 0;) - s6 = 1 - goto l00000000000153DC - // succ: l00000000000153DC -l0000000000015D18: - a2 = Mem0[sp + 104:word64] - a1 = 0x12000<64> - a1 = a1 + -984 - a0 = 1 - a0 = SEQ(0<32>, __printf_chk(SLICE(a0, int32, 0), a1, a2)) - goto l00000000000159D0 - // succ: l00000000000159D0 -l0000000000015D30: - a2 = Mem0[sp + 88:word64] - a1 = 0x12000<64> - a1 = a1 + -936 - a0 = 1 - a0 = SEQ(0<32>, __printf_chk(SLICE(a0, int32, 0), a1, a2)) - goto l0000000000015A04 - // succ: l0000000000015A04 -l0000000000015D48: - a2 = CONVERT(Mem0[sp + 216:int32], int32, int64) - a1 = 0x12000<64> - a1 = a1 + -968 - a0 = 1 - a0 = SEQ(0<32>, __printf_chk(SLICE(a0, int32, 0), a1, SLICE(a2, uint32, 0))) - goto l00000000000159D8 - // succ: l00000000000159D8 -l0000000000015D60: - a1 = 0x12000<64> - a2 = s1 - a1 = a1 + -792 - a0 = 1 - a0 = SEQ(0<32>, __printf_chk(SLICE(a0, int32, 0), a1, a2)) - goto l0000000000015AD4 - // succ: l0000000000015AD4 -l0000000000015D78: - a2 = Mem0[sp + 80:word64] - a1 = 0x12000<64> - a1 = a1 + -920 - a0 = 1 - a0 = SEQ(0<32>, __printf_chk(SLICE(a0, int32, 0), a1, a2)) - goto l0000000000015A0C - // succ: l0000000000015A0C -l0000000000015D90: - a1 = 0x12000<64> - a1 = a1 + -824 - a0 = 1 - a0 = SEQ(0<32>, __printf_chk(SLICE(a0, int32, 0), a1, a2)) - goto l0000000000015AAC - // succ: l0000000000015AAC -l0000000000015DA4: - a1 = 0x12000<64> - a1 = a1 + -856 - a0 = 1 - a0 = SEQ(0<32>, __printf_chk(SLICE(a0, int32, 0), a1, a2)) - goto l0000000000015A80 - // succ: l0000000000015A80 -l0000000000015DB8: - branch a4 == a3 l0000000000015E00 - // succ: l0000000000015DBC l0000000000015E00 -l0000000000015DBC: - a4 = -84 - Mem0[sp + 256:byte] = SLICE(a4, byte, 0) - a4 = Mem0[sp + 48:word64] - a4 = a4 >> 4 - a4 = a4 & 15 - a4 = a4 | 16 - Mem0[sp + 257:byte] = SLICE(a4, byte, 0) - goto l0000000000015C84 - // succ: l0000000000015C84 -l0000000000015DDC: - a3 = Mem0[sp + 56:word64] - s2 = 0x12000<64> - s1 = 0x12000<64> - a1 = 0x12000<64> - a2 = s2 + -928 - a1 = a1 + -1264 - a0 = s1 + -1272 - call fn000000000001654C (retsize: 0;) - goto l00000000000158B8 - // succ: l00000000000158B8 -l0000000000015E00: - a4 = -64 - Mem0[sp + 256:byte] = SLICE(a4, byte, 0) - a4 = -88 - Mem0[sp + 257:byte] = SLICE(a4, byte, 0) - goto l0000000000015C84 - // succ: l0000000000015C84 -l0000000000015E14: - s2 = 0x12000<64> - s1 = 0x12000<64> - a1 = 0x12000<64> - a2 = s2 + -928 - a3 = s3 - a1 = a1 + -1264 - a0 = s1 + -1272 - call fn000000000001654C (retsize: 0;) - s2 = CONVERT(Mem0[sp + 216:int32], int32, int64) - goto l0000000000015668 - // succ: l0000000000015668 +l00000000000156FC: + putchar(10) + a3_1060 = Mem513[&tLoc0188 + 184:word64] + branch a3_1060 == 0<64> l0000000000015728 +l000000000001570C: + gp = fn000000000001654C(gp, a3_1060, a4_1016, a5_1017, a6_1018, a7, out a4_1016, out a5_1017, out a6_1018, out a7) +l0000000000015728: + a3_1085 = Mem513[&tLoc0188 + 192:word64] + branch a3_1085 == 0<64> l000000000001574C +l0000000000015730: + gp = fn000000000001654C(gp, a3_1085, a4_1016, a5_1017, a6_1018, a7, out a4_1016, out a5_1017, out a6_1018, out a7) +l000000000001574C: + a3_1110 = Mem513[&tLoc0188 + 168:word64] + branch a3_1110 == 0<64> l000000000001576C +l0000000000015754: + gp = fn000000000001654C(gp, a3_1110, a4_1016, a5_1017, a6_1018, a7, out a4_1016, out a5_1017, out a6_1018, out a7) +l000000000001576C: + a3_1137 = Mem513[&tLoc0188 + 176:word64] + branch a3_1137 == 0<64> l000000000001578C +l0000000000015774: + gp = fn000000000001654C(gp, a3_1137, a4_1016, a5_1017, a6_1018, a7, out a4_1016, out a5_2686, out a6_1018, out a7) +l000000000001578C: + a5_1162 = CONVERT(Mem513[&qwLoc01A8 + 4:int32], int32, int64) + branch a5_1162 == 0<64> l00000000000157A0 +l0000000000015794: + a5_1162 = CONVERT(Mem513[&tLoc0188 + 160:int32], int32, int64) + a4_1016 = 111 + branch a5_1162 <=u 111 l0000000000015E3C l0000000000015E3C: - a3 = 128 - a2 = 0x12000<64> - a1 = 0x12000<64> - a4 = sp + 152 - v37 = SLICE(a3, word32, 0) - v38 = SLICE(a5, word32, 0) - a3 = CONVERT(v37 - v38, word32, int64) - a2 = a2 + -1072 - a1 = a1 + -1056 - a0 = s1 + -1272 - call fn000000000001654C (retsize: 0;) - goto l00000000000157BC - // succ: l00000000000157BC -l0000000000015E64: - a3 = Mem0[sp + 80:word64] - s0 = 1 - branch a3 != 0<64> l0000000000015C2C - // succ: l0000000000015E70 l0000000000015C2C -l0000000000015E70: - goto l00000000000158C8 - // succ: l00000000000158C8 -l0000000000015E74: - s2 = CONVERT(Mem0[sp + 216:int32], int32, int64) - goto l0000000000015668 - // succ: l0000000000015668 -l0000000000015E7C: - a3 = 0x12000<64> - a3 = a3 + -1640 - a4 = s10 - goto l0000000000015B8C - // succ: l0000000000015B8C + gp = fn000000000001654C(gp, CONVERT(0x80<32> - SLICE(a5_1162, word32, 0), word32, int64), &tLoc0188 + 96, a5_1162, a6_1018, a7, out a4_1016, out a5_2688, out a6_1018, out a7) +l00000000000157A0: + gp = fn000000000001654C(gp, &tLoc0188 + 96, a4_1016, a5_1162, a6_1018, a7, out a4_1016, out a5_2687, out a6_1018, out a7) +l00000000000157BC: + a5_1218 = Mem513[&tLoc0188 + 64:word64] + branch a5_1218 == 0<64> l0000000000015C08 +l0000000000015C08: + a5_1218 = Mem513[&tLoc0188 + 80:word64] + branch a5_1218 != 0<64> l00000000000157C4 +l0000000000015C10: + a5_1218 = Mem513[&tLoc0188 + 88:word64] + branch a5_1218 != 0<64> l00000000000157C4 +l0000000000015C18: +l00000000000157C4: + putchar(10) + a3_1225 = Mem513[&tLoc0188 + 72:word64] + branch a3_1225 == 0<64> l00000000000157F0 +l00000000000157D4: + gp = fn000000000001654C(gp, a3_1225, a4_1016, a5_1218, a6_1018, a7, out a4_1016, out a5_1218, out a6_1018, out a7) +l00000000000157F0: + a3_1254 = Mem513[&tLoc0188 + 64:word64] + branch a3_1254 == 0<64> l0000000000015814 +l00000000000157F8: + gp = fn000000000001654C(gp, a3_1254, a4_1016, a5_1218, a6_1018, a7, out a4_1016, out a5_1218, out a6_1018, out a7) +l0000000000015814: + a3_1279 = Mem513[&tLoc0188 + 80:word64] + branch a3_1279 == 0<64> l0000000000015838 +l000000000001581C: + gp = fn000000000001654C(gp, a3_1279, a4_1016, a5_1218, a6_1018, a7, out a4_1016, out a5_1218, out a6_1018, out a7) +l0000000000015838: + a3_1304 = Mem513[&tLoc0188 + 88:word64] + branch a3_1304 == 0<64> l00000000000153DC +l0000000000015840: + gp = fn000000000001654C(gp, a3_1304, a4_1016, a5_1218, a6_1018, a7, out a4_2689, out a5_2690, out a6_2691, out a7_2692) +l00000000000153D0: + branch CONVERT(Mem97[gp + -2028:int32], int32, int64) == 0<64> l000000000001556C +l000000000001556C: + fwrite(0x11A08<64>, SLICE(1, size_t, 0), SLICE(37, size_t, 0), Mem97[gp + -1920:word64]) +l000000000001538C: + branch CONVERT(Mem91[gp + -2028:int32], int32, int64) != 0<64> l00000000000153D8 +l00000000000153D8: +l0000000000015394: + fwrite(0x119D8<64>, SLICE(1, size_t, 0), SLICE(46, size_t, 0), Mem91[gp + -1920:word64]) +l00000000000153DC: + branch a5_7 != Mem1350[gp + -1936:word64] l0000000000015E8C l0000000000015E8C: __stack_chk_fail() -l0000000000015E90: - a1 = 0x12000<64> - a1 = a1 + -744 - a0 = 1 - a0 = SEQ(0<32>, __printf_chk(SLICE(a0, int32, 0), a1, a2)) - goto l0000000000015B24 - // succ: l0000000000015B24 -l0000000000015EA4: - a1 = 0x12000<64> - a1 = a1 + -712 - a0 = 1 - a0 = SEQ(0<32>, __printf_chk(SLICE(a0, int32, 0), a1, a2)) - goto l0000000000015B50 - // succ: l0000000000015B50 +l00000000000153EC: + return +l0000000000015224: + branch a0_61 >u 118 l0000000000015200 +l000000000001522C: + a5_1449 = CONVERT(Mem51[(a0_61 << 0x20 >>u 0x1E) + 0x102A0<64>:int32], int32, int64) + call a5_1449 (retsize: 0;) + uses: a0:a0_61,a1:a1,a4:0x102A0<64>,a5:a5_1449,a6:a6_1475,a7:a7_1478,gp:gp,Mem:Mem51,ra:ra,s0:0,s1:0x108E0<64>,s10:0,s11:s11,s2:a1,s3:a0,s4:0x12000<64>,s5:s5,s6:0,s7:1,s8:0x1000<64>,s9:0,Stack +0018:qwLoc01A8,Stack +0020:ptrLoc01A0,Stack +0028:tLoc0198,Stack +0030:qwLoc0190,Stack +0038:tLoc0188,Stack +0100:qwLocC0,Stack +0108:bLocB8,t1:t1_1476,t3:t3_1477 + defs: a6:a6_1475,a7:a7_1478,t1:t1_1476,t3:t3_1477 + return fn0000000000015180_exit: -// fn0000000000015EB8 -// Return size: 0 -define fn0000000000015EB8 +void fn0000000000015EB8(word64 a0, word32 dwArg00, char * ptrArg08) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// MayUse: a0:[0..63] Stack +0000:[0..31] Stack +0008:[0..63] +// LiveOut: +// Trashed: a0 a1 a2 a3 a4 a5 a6 gp sp +// Preserved: fn0000000000015EB8_entry: - sp = fp - // succ: l0000000000015EB8 l0000000000015EB8: - gp = 0x0000000000012EB8 - gp = gp + 1424 - a5 = a0 - a0 = 0x0000000000014EC4 - a0 = a0 + 700 - a1 = Mem0[sp:word64] - a2 = sp + 8 - sp = sp & -16 - a3 = 0x0000000000017ED8 - a3 = a3 + 1040 - a4 = 0x0000000000017EE0 - a4 = a4 + 1176 - a6 = sp - a0 = SEQ(0<32>, __libc_start_main(a0, SLICE(a1, int32, 0), a2, a3, a4, a5, a6)) + __libc_start_main(0x0000000000015180, SLICE(qwArg00, int32, 0), &ptrArg08, 0x00000000000182E8, 0x0000000000018378, a0, fp & -16) return - // succ: fn0000000000015EB8_exit fn0000000000015EB8_exit: -// fn0000000000015EF0 -// Return size: 0 -define fn0000000000015EF0 +void fn0000000000015EF0() +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// Called from: +// fn0000000000015F64 +// MayUse: +// LiveOut: +// Trashed: a0 a4 a5 ra t1 +// Preserved: sp fn0000000000015EF0_entry: - sp = fp - // succ: l0000000000015EF0 l0000000000015EF0: - a0 = 0x10000<64> - a5 = 0x10000<64> - a4 = a0 + 672 - a5 = a5 + 679 - a5 = a5 - a4 - a4 = 14 - branch a4 >=u a5 l0000000000015F20 - // succ: l0000000000015F0C l0000000000015F20 + branch true l0000000000015F20 l0000000000015F0C: - t1 = 0<64> - t1 = t1 - branch t1 == 0<64> l0000000000015F20 - // succ: l0000000000015F18 l0000000000015F20 -l0000000000015F18: - a0 = a0 + 672 - call t1 (retsize: 0;) - return - // succ: fn0000000000015EF0_exit + branch true l0000000000015F20 l0000000000015F20: return - // succ: fn0000000000015EF0_exit +l0000000000015F18: + call 0<64> (retsize: 0;) + uses: a0:0x102A0<64>,Mem:Mem0,ra:ra_18,t1:t1_17 + defs: ra:ra_18,t1:t1_17 + return fn0000000000015EF0_exit: -// fn0000000000015F24 -// Return size: 0 -define fn0000000000015F24 +void fn0000000000015F24() +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// Called from: +// fn0000000000015F94 +// MayUse: +// LiveOut: +// Trashed: a0 a1 a5 t1 +// Preserved: sp fn0000000000015F24_entry: - sp = fp - // succ: l0000000000015F24 l0000000000015F24: - a0 = 0x10000<64> - a5 = 0x10000<64> - a1 = a0 + 672 - a5 = a5 + 672 - a5 = a5 - a1 - a5 = a5 >> 3 - a1 = a5 >>u 0x3F - a1 = a1 + a5 - a1 = a1 >> 1 - branch a1 == 0<64> l0000000000015F60 - // succ: l0000000000015F4C l0000000000015F60 + branch true l0000000000015F60 l0000000000015F4C: - t1 = 0<64> - t1 = t1 - branch t1 == 0<64> l0000000000015F60 - // succ: l0000000000015F58 l0000000000015F60 -l0000000000015F58: - a0 = a0 + 672 - call t1 (retsize: 0;) - return - // succ: fn0000000000015F24_exit + branch true l0000000000015F60 l0000000000015F60: return - // succ: fn0000000000015F24_exit +l0000000000015F58: + call 0<64> (retsize: 0;) + uses: a0:0x102A0<64>,Mem:Mem0,t1:t1_20 + defs: t1:t1_20 + return fn0000000000015F24_exit: -// fn0000000000015F64 -// Return size: 0 -define fn0000000000015F64 +void fn0000000000015F64(word64 gp) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// MayUse: gp:[0..63] +// LiveOut: +// Trashed: a0 a4 a5 t1 +// Preserved: ra s0 sp fn0000000000015F64_entry: - sp = fp - // succ: l0000000000015F64 l0000000000015F64: - sp = sp + -16 - Mem0[sp:word64] = s0 - a5 = CONVERT(Mem0[gp + -1900:byte], byte, word64) - Mem0[sp + 8:word64] = ra - branch a5 != 0<64> l0000000000015F84 - // succ: l0000000000015F78 l0000000000015F84 + branch CONVERT(Mem5[gp + -1900:byte], byte, word64) != 0<64> l0000000000015F84 l0000000000015F78: - call fn0000000000015EF0 (retsize: 0;) - a5 = 1 - Mem0[gp + -1900:byte] = SLICE(a5, byte, 0) - // succ: l0000000000015F84 + fn0000000000015EF0() + Mem16[gp + -1900:byte] = 1<8> l0000000000015F84: - ra = Mem0[sp + 8:word64] - s0 = Mem0[sp:word64] - sp = sp + 16 return - // succ: fn0000000000015F64_exit fn0000000000015F64_exit: -// fn0000000000015F94 -// Return size: 0 -define fn0000000000015F94 +void fn0000000000015F94() +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// MayUse: +// LiveOut: +// Trashed: a0 a1 a5 t1 +// Preserved: ra sp fn0000000000015F94_entry: - sp = fp - // succ: l0000000000015F94 l0000000000015F94: - a5 = 0x1A000<64> - a0 = a5 + -472 - a5 = Mem0[a0:word64] - branch a5 != 0<64> l0000000000015FA8 - // succ: l0000000000015FA4 l0000000000015FA8 -l0000000000015FA4: - // succ: l0000000000015FA4_thunk_fn0000000000015F24 -l0000000000015FA4_thunk_fn0000000000015F24: - call fn0000000000015F24 (retsize: 0;) - return - // succ: fn0000000000015F94_exit + branch Mem0[0x19E28<64>:word64] != 0<64> l0000000000015FA8 l0000000000015FA8: - a5 = 0<64> - a5 = a5 - branch a5 == 0<64> l0000000000015FA4 - // succ: l0000000000015FB4 l0000000000015FA4 + branch true l0000000000015FA4 l0000000000015FB4: - sp = sp + -16 - Mem0[sp + 8:word64] = ra - call fn0000000000000000 (retsize: 0;) - ra = Mem0[sp + 8:word64] - sp = sp + 16 - // succ: l0000000000015FC8_thunk_fn0000000000015F24 + fn0000000000000000() l0000000000015FC8_thunk_fn0000000000015F24: - call fn0000000000015F24 (retsize: 0;) + fn0000000000015F24() + return +l0000000000015FA4: +l0000000000015FA4_thunk_fn0000000000015F24: + fn0000000000015F24() return - // succ: fn0000000000015F94_exit fn0000000000015F94_exit: -// fn0000000000015FCC -// Return size: 0 -define fn0000000000015FCC +void fn0000000000015FCC(word64 gp, word64 a0) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// Called from: +// fn0000000000015180 +// MayUse: a0:[0..63] gp:[0..63] +// LiveOut: +// Trashed: a0 a1 a2 a3 t1 t3 +// Preserved: ra s0 sp fn0000000000015FCC_entry: - sp = fp - // succ: l0000000000015FCC l0000000000015FCC: - sp = sp + -16 - Mem0[sp:word64] = s0 - Mem0[sp + 8:word64] = ra - a3 = Mem0[gp + -1920:word64] + a3_9 = Mem7[gp + -1920:word64] branch a0 != 0<64> l0000000000016090 - // succ: l0000000000015FE0 l0000000000016090 -l0000000000015FE0: - a0 = 0x11000<64> - a2 = 77 - a1 = 1 - a0 = a0 + 1032 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 62 - a1 = 1 - a0 = a0 + 1112 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 65 - a1 = 1 - a0 = a0 + 1176 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 76 - a1 = 1 - a0 = a0 + 1248 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 65 - a1 = 1 - a0 = a0 + 1328 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 41 - a1 = 1 - a0 = a0 + 1400 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - ra = Mem0[sp + 8:word64] - s0 = Mem0[sp:word64] - a0 = 0x11000<64> - a2 = 30 - a1 = 1 - a0 = a0 + 1448 - sp = sp + 16 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - return - // succ: fn0000000000015FCC_exit l0000000000016090: - a0 = 0x11000<64> - a2 = 26 - a1 = 1 - a0 = a0 + -1056 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 54 - a1 = 1 - a0 = a0 + -1024 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 77 - a1 = 1 - a0 = a0 + -968 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 62 - a1 = 1 - a0 = a0 + -888 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 79 - a1 = 1 - a0 = a0 + -824 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 79 - a1 = 1 - a0 = a0 + -744 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 42 - a1 = 1 - a0 = a0 + -664 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 76 - a1 = 1 - a0 = a0 + -616 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 77 - a1 = 1 - a0 = a0 + -536 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 77 - a1 = 1 - a0 = a0 + -456 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a1 = Mem0[gp + -1920:word64] - a0 = 10 - call fputc (retsize: 0;) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 23 - a1 = 1 - a0 = a0 + -376 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 71 - a1 = 1 - a0 = a0 + -352 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 57 - a1 = 1 - a0 = a0 + -280 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 58 - a1 = 1 - a0 = a0 + -216 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 57 - a1 = 1 - a0 = a0 + -152 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 77 - a1 = 1 - a0 = a0 + -88 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 77 - a1 = 1 - a0 = a0 + -8 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 77 - a1 = 1 - a0 = a0 + 72 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 46 - a1 = 1 - a0 = a0 + 152 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 72 - a1 = 1 - a0 = a0 + 200 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 45 - a1 = 1 - a0 = a0 + 280 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 67 - a1 = 1 - a0 = a0 + 328 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 64 - a1 = 1 - a0 = a0 + 400 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 72 - a1 = 1 - a0 = a0 + 472 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 46 - a1 = 1 - a0 = a0 + 552 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a1 = Mem0[gp + -1920:word64] - a0 = 10 - call fputc (retsize: 0;) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 15 - a1 = 1 - a0 = a0 + 600 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 87 - a1 = 1 - a0 = a0 + 616 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 60 - a1 = 1 - a0 = a0 + 704 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 68 - a1 = 1 - a0 = a0 + 768 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 58 - a1 = 1 - a0 = a0 + 840 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 57 - a1 = 1 - a0 = a0 + 904 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a3 = Mem0[gp + -1920:word64] - ra = Mem0[sp + 8:word64] - s0 = Mem0[sp:word64] - a0 = 0x11000<64> - a2 = 62 - a1 = 1 - a0 = a0 + 968 - sp = sp + 16 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) + fwrite(0x10BE0<64>, SLICE(1, size_t, 0), SLICE(26, size_t, 0), a3_9) + fwrite(0x10C00<64>, SLICE(1, size_t, 0), SLICE(54, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x10C38<64>, SLICE(1, size_t, 0), SLICE(77, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x10C88<64>, SLICE(1, size_t, 0), SLICE(62, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x10CC8<64>, SLICE(1, size_t, 0), SLICE(79, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x10D18<64>, SLICE(1, size_t, 0), SLICE(79, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x10D68<64>, SLICE(1, size_t, 0), SLICE(42, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x10D98<64>, SLICE(1, size_t, 0), SLICE(76, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x10DE8<64>, SLICE(1, size_t, 0), SLICE(77, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x10E38<64>, SLICE(1, size_t, 0), SLICE(77, size_t, 0), Mem7[gp + -1920:word64]) + fputc() + fwrite(0x10E88<64>, SLICE(1, size_t, 0), SLICE(23, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x10EA0<64>, SLICE(1, size_t, 0), SLICE(71, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x10EE8<64>, SLICE(1, size_t, 0), SLICE(57, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x10F28<64>, SLICE(1, size_t, 0), SLICE(58, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x10F68<64>, SLICE(1, size_t, 0), SLICE(57, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x10FA8<64>, SLICE(1, size_t, 0), SLICE(77, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x10FF8<64>, SLICE(1, size_t, 0), SLICE(77, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x11048<64>, SLICE(1, size_t, 0), SLICE(77, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x11098<64>, SLICE(1, size_t, 0), SLICE(46, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x110C8<64>, SLICE(1, size_t, 0), SLICE(72, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x11118<64>, SLICE(1, size_t, 0), SLICE(45, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x11148<64>, SLICE(1, size_t, 0), SLICE(67, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x11190<64>, SLICE(1, size_t, 0), SLICE(64, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x111D8<64>, SLICE(1, size_t, 0), SLICE(72, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x11228<64>, SLICE(1, size_t, 0), SLICE(46, size_t, 0), Mem7[gp + -1920:word64]) + fputc() + fwrite(0x11258<64>, SLICE(1, size_t, 0), SLICE(15, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x11268<64>, SLICE(1, size_t, 0), SLICE(87, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x112C0<64>, SLICE(1, size_t, 0), SLICE(60, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x11300<64>, SLICE(1, size_t, 0), SLICE(68, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x11348<64>, SLICE(1, size_t, 0), SLICE(58, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x11388<64>, SLICE(1, size_t, 0), SLICE(57, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x113C8<64>, SLICE(1, size_t, 0), SLICE(62, size_t, 0), Mem7[gp + -1920:word64]) + return +l0000000000015FE0: + fwrite(0x11408<64>, SLICE(1, size_t, 0), SLICE(77, size_t, 0), a3_9) + fwrite(0x11458<64>, SLICE(1, size_t, 0), SLICE(62, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x11498<64>, SLICE(1, size_t, 0), SLICE(65, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x114E0<64>, SLICE(1, size_t, 0), SLICE(76, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x11530<64>, SLICE(1, size_t, 0), SLICE(65, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x11578<64>, SLICE(1, size_t, 0), SLICE(41, size_t, 0), Mem7[gp + -1920:word64]) + fwrite(0x115A8<64>, SLICE(1, size_t, 0), SLICE(30, size_t, 0), Mem7[gp + -1920:word64]) return - // succ: fn0000000000015FCC_exit fn0000000000015FCC_exit: -// fn00000000000163B0 -// Return size: 0 -define fn00000000000163B0 +word64 fn00000000000163B0(word64 gp, word64 a0) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// Called from: +// fn00000000000175BC +// MayUse: a0:[0..63] gp:[0..63] +// LiveOut: a0:[0..63]-fn00000000000175BC +// Trashed: a0 a1 a2 a3 a4 a5 +// Preserved: ra s0 s1 s2 s3 s4 s5 s6 s7 s8 s9 sp fn00000000000163B0_entry: - sp = fp - // succ: l00000000000163B0 l00000000000163B0: - sp = sp + -240 - Mem0[sp + 224:word64] = s0 - Mem0[sp + 216:word64] = s1 - Mem0[sp + 208:word64] = s2 - Mem0[sp + 200:word64] = s3 - Mem0[sp + 192:word64] = s4 - Mem0[sp + 184:word64] = s5 - Mem0[sp + 176:word64] = s6 - Mem0[sp + 168:word64] = s7 - Mem0[sp + 160:word64] = s8 - Mem0[sp + 152:word64] = s9 - Mem0[sp + 232:word64] = ra - a5 = Mem0[gp + -1936:word64] - a4 = CONVERT(Mem0[a0:byte], byte, word64) - s4 = 0x11000<64> - s0 = 0 - s2 = a0 - a3 = s4 + 1480 - a2 = 128 - a1 = 1 - a0 = sp + 8 - s3 = 16 - v22 = SLICE(s0, word32, 0) - s0 = CONVERT(v22 + 1, word32, int64) - Mem0[sp + 136:word64] = a5 - s2 = s2 + 1 - a0 = SEQ(0<32>, __sprintf_chk(a0, SLICE(a1, int32, 0), SLICE(a2, size_t, 0), a3, SLICE(a4, uint32, 0))) - s1 = sp + 10 - s6 = 128 - s5 = 1 - s9 = 15 - s7 = 58 - branch s0 == s3 l000000000001646C - // succ: l0000000000016430 l000000000001646C + a5_27 = Mem25[gp + -1936:word64] + __sprintf_chk(&bLocE8, 1, SLICE(128, size_t, 0), 0x115C8<64>, CONVERT(Mem25[a0:byte], byte, uint32)) + s0_39 = 1 + s2_101 = a0 + 1 + s1_43 = fp + -230 + branch false l000000000001646C l0000000000016430: - a4 = CONVERT(Mem0[s2:byte], byte, word64) - a3 = s4 + 1480 - a2 = s6 - a1 = s5 - a0 = s1 - a0 = SEQ(0<32>, __sprintf_chk(a0, SLICE(a1, int32, 0), SLICE(a2, size_t, 0), a3, SLICE(a4, uint32, 0))) - a5 = s0 & 1 - a4 = s1 + 2 - branch a5 == 0<64> l00000000000164B8 - // succ: l0000000000016454 l00000000000164B8 + __sprintf_chk(s1_43, 1, SLICE(128, size_t, 0), 0x115C8<64>, CONVERT(Mem49[s2_101:byte], byte, uint32)) + a4_62 = s1_43 + 2 + branch (s0_39 & 1) == 0<64> l00000000000164B8 +l00000000000164B8: + s1_43 = a4_62 + s2_101 = s2_101 + 1 l0000000000016454: - branch s0 == s9 l00000000000164C4 - // succ: l0000000000016458 l00000000000164C4 + branch s0_39 == 15 l00000000000164C4 +l00000000000164C4: + s1_43 = a4_62 l0000000000016458: - Mem0[s1 + 2:byte] = SLICE(s7, byte, 0) - s2 = s2 + 1 - s1 = s1 + 3 - // succ: l0000000000016464 + Mem68[s1_43 + 2:byte] = 0x3A<8> + s2_101 = s2_101 + 1 + s1_43 = s1_43 + 3 l0000000000016464: - v27 = SLICE(s0, word32, 0) - s0 = CONVERT(v27 + 1, word32, int64) - branch s0 != s3 l0000000000016430 - // succ: l000000000001646C l0000000000016430 + s0_39 = CONVERT(SLICE(s0_39, word32, 0) + 1, word32, int64) + branch s0_39 != 16 l0000000000016430 l000000000001646C: - Mem0[s1:byte] = SLICE(0<64>, byte, 0) - a0 = sp + 8 - a0 = __strdup(a0) - a4 = Mem0[sp + 136:word64] - a5 = Mem0[gp + -1936:word64] - branch a4 != a5 l00000000000164CC - // succ: l0000000000016484 l00000000000164CC -l0000000000016484: - ra = Mem0[sp + 232:word64] - s0 = Mem0[sp + 224:word64] - s1 = Mem0[sp + 216:word64] - s2 = Mem0[sp + 208:word64] - s3 = Mem0[sp + 200:word64] - s4 = Mem0[sp + 192:word64] - s5 = Mem0[sp + 184:word64] - s6 = Mem0[sp + 176:word64] - s7 = Mem0[sp + 168:word64] - s8 = Mem0[sp + 160:word64] - s9 = Mem0[sp + 152:word64] - sp = sp + 240 - return - // succ: fn00000000000163B0_exit -l00000000000164B8: - s1 = a4 - s2 = s2 + 1 - goto l0000000000016464 - // succ: l0000000000016464 -l00000000000164C4: - s1 = a4 - goto l000000000001646C - // succ: l000000000001646C + Mem78[s1_43:byte] = 0<8> + a0_83 = __strdup(&bLocE8) + branch a5_27 != Mem78[gp + -1936:word64] l00000000000164CC l00000000000164CC: __stack_chk_fail() +l0000000000016484: + return a0_83 fn00000000000163B0_exit: -// fn00000000000164D0 -// Return size: 0 -define fn00000000000164D0 +word64 fn00000000000164D0(word64 a0, word64 a1) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// Called from: +// fn0000000000015180 +// MayUse: a0:[0..63] a1:[0..31] +// LiveOut: a0:[0..63]-fn0000000000015180 +// Trashed: a0 a1 a2 +// Preserved: ra s0 s1 s2 sp fn00000000000164D0_entry: - sp = fp - // succ: l00000000000164D0 l00000000000164D0: - sp = sp + -32 - Mem0[sp + 16:word64] = s0 - s0 = a0 - a0 = 0x11000<64> - Mem0[sp:word64] = s2 - a0 = a0 + 1488 - s2 = a1 - a1 = 0 - Mem0[sp + 24:word64] = ra - Mem0[sp + 8:word64] = s1 - a0 = SEQ(0<32>, open(a0, SLICE(a1, int32, 0))) - branch a0 < 0<64> l0000000000016544 - // succ: l0000000000016500 l0000000000016544 + a0_19 = CONVERT(open(0x115D0<64>, 0), uint32, uint64) + branch a0_19 < 0<64> l0000000000016544 +l0000000000016544: + a0_20 = -1 l0000000000016500: - a2 = s2 << 0x20 - a1 = s0 - a2 = a2 >>u 0x20 - s1 = a0 - a0 = SEQ(0<64>, read(SLICE(a0, int32, 0), a1, SLICE(a2, size_t, 0))) - s0 = a0 - a0 = s1 - a0 = SEQ(0<32>, close(SLICE(a0, int32, 0))) - v14 = SLICE(s0, word32, 0) - v15 = SLICE(s2, word32, 0) - a0 = CONVERT(v14 - v15, word32, int64) - a0 = CONVERT(a0 != 0<64>, bool, word64) - v16 = 0<32> - v17 = SLICE(a0, word32, 0) - a0 = CONVERT(v16 - v17, word32, int64) - // succ: l000000000001652C + a0_25 = CONVERT(read(SLICE(a0_19, int32, 0), a0, SLICE(a1, size_t, 0)), uint0, uint64) + close(SLICE(a0_19, int32, 0)) + a0_20 = CONVERT(0<32> - CONVERT(CONVERT(SLICE(a0_25 - a1, word32, 0), word32, int64) != 0<64>, bool, word32), word32, int64) l000000000001652C: - ra = Mem0[sp + 24:word64] - s0 = Mem0[sp + 16:word64] - s1 = Mem0[sp + 8:word64] - s2 = Mem0[sp:word64] - sp = sp + 32 - return - // succ: fn00000000000164D0_exit -l0000000000016544: - a0 = -1 - goto l000000000001652C - // succ: l000000000001652C + return a0_20 fn00000000000164D0_exit: -// fn000000000001654C -// Return size: 0 -define fn000000000001654C +word64 fn000000000001654C(word64 gp, word64 a3, word64 a4, word64 a5, word64 a6, word64 a7, ptr64 & a4Out, ptr64 & a5Out, ptr64 & a6Out, ptr64 & a7Out) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// Called from: +// fn0000000000015180 +// MayUse: a3:[0..63] a4:[0..63] a5:[0..63] a6:[0..63] a7:[0..63] gp:[0..63] +// LiveOut: a4:[0..63]-fn0000000000015180 a5:[0..63]-fn0000000000015180 a6:[0..63]-fn0000000000015180 a7:[0..63]-fn0000000000015180 gp:[0..63]-fn0000000000015180 +// Trashed: a0 a1 a2 a3 a4 a5 a6 a7 gp t1 t3 +// Preserved: ra s0 s1 s2 s3 sp fn000000000001654C_entry: - sp = fp - // succ: l000000000001654C l000000000001654C: - sp = sp + -128 - Mem0[sp + 64:word64] = s0 - t3 = Mem0[gp + -1936:word64] - t1 = sp + 88 - Mem0[sp + 48:word64] = s2 - Mem0[sp + 40:word64] = s3 - s2 = a1 - s3 = a0 - Mem0[sp + 88:word64] = a3 - a1 = 1 - a3 = t1 - a0 = sp + 16 - Mem0[sp + 72:word64] = ra - Mem0[sp + 56:word64] = s1 - Mem0[sp + 96:word64] = a4 - Mem0[sp + 104:word64] = a5 - Mem0[sp + 112:word64] = a6 - Mem0[sp + 120:word64] = a7 - Mem0[sp + 24:word64] = t3 - Mem0[sp + 16:word64] = 0<64> - Mem0[sp + 8:word64] = t1 - call __vasprintf_chk (retsize: 0;) - branch a0 < 0<64> l00000000000165D8 - // succ: l00000000000165A8 l00000000000165D8 + t3_7 = Mem5[gp + -1936:word64] + __vasprintf_chk(fp + -112, 1, fp + -40, fp + -40, a3, a4, a5, a6, a7) + branch a0_45 < 0<64> l00000000000165D8 l00000000000165A8: - a1 = Mem0[gp + -1912:word64] - a0 = s2 - a0 = SEQ(0<32>, fputs(a0, a1)) - a5 = CONVERT(Mem0[gp + -2032:int32], int32, int64) - branch a5 != 0<64> l000000000001661C - // succ: l00000000000165BC l000000000001661C + fputs(s2_42, Mem36[gp_39 + -1912:word64]) + branch CONVERT(Mem36[gp_39 + -2032:int32], int32, int64) != 0<64> l000000000001661C +l000000000001661C: + fputs(s3_43, Mem36[gp_39 + -1912:word64]) l00000000000165BC: - a1 = Mem0[gp + -1912:word64] - a0 = Mem0[sp + 16:word64] - a0 = SEQ(0<32>, fputs(a0, a1)) - a5 = CONVERT(Mem0[gp + -2032:int32], int32, int64) - branch a5 != 0<64> l0000000000016600 - // succ: l00000000000165D0 l0000000000016600 + fputs(0<64>, Mem36[gp_39 + -1912:word64]) + branch CONVERT(Mem36[gp_39 + -2032:int32], int32, int64) != 0<64> l0000000000016600 +l0000000000016600: + fwrite(0x115E0<64>, SLICE(1, size_t, 0), SLICE(4, size_t, 0), Mem36[gp_39 + -1912:word64]) l00000000000165D0: - a0 = Mem0[sp + 16:word64] - free(a0) - // succ: l00000000000165D8 + free(0<64>) l00000000000165D8: - a4 = Mem0[sp + 24:word64] - a5 = Mem0[gp + -1936:word64] - branch a4 != a5 l000000000001662C - // succ: l00000000000165E4 l000000000001662C -l00000000000165E4: - ra = Mem0[sp + 72:word64] - s0 = Mem0[sp + 64:word64] - s1 = Mem0[sp + 56:word64] - s2 = Mem0[sp + 48:word64] - s3 = Mem0[sp + 40:word64] - sp = sp + 128 - return - // succ: fn000000000001654C_exit -l0000000000016600: - a3 = Mem0[gp + -1912:word64] - a0 = 0x11000<64> - a2 = 4 - a1 = 1 - a0 = a0 + 1504 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - goto l00000000000165D0 - // succ: l00000000000165D0 -l000000000001661C: - a1 = Mem0[gp + -1912:word64] - a0 = s3 - a0 = SEQ(0<32>, fputs(a0, a1)) - goto l00000000000165BC - // succ: l00000000000165BC + a5_82 = Mem36[gp_39 + -1936:word64] + branch t3_7 != a5_82 l000000000001662C l000000000001662C: __stack_chk_fail() +l00000000000165E4: + a4Out = t3_7 + a5Out = a5_82 + a6Out = a6_51 + a7Out = a7_52 + return gp_39 fn000000000001654C_exit: -// fn0000000000016630 -// Return size: 0 -define fn0000000000016630 +word64 fn0000000000016630(word64 gp, word64 a0, word64 a1) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// Called from: +// fn00000000000166F4 +// MayUse: a0:[0..63] a1:[0..63] gp:[0..63] +// LiveOut: a0:[0..63]-fn00000000000166F4 +// Trashed: a0 a1 a2 a3 a4 a5 +// Preserved: ra s0 s1 s2 s3 sp fn0000000000016630_entry: - sp = fp - // succ: l0000000000016630 l0000000000016630: - sp = sp + -64 - Mem0[sp + 48:word64] = s0 - a5 = Mem0[gp + -1936:word64] - Mem0[sp + 56:word64] = ra - Mem0[sp + 40:word64] = s1 - Mem0[sp + 8:word64] = a5 - Mem0[sp + 32:word64] = s2 - Mem0[sp + 24:word64] = s3 - s2 = a0 - s3 = a1 - Mem0[sp:word64] = 0<64> - a0 = __errno_location() - Mem0[a0:word32] = SLICE(0<64>, word32, 0) - s1 = a0 - a2 = 0 - a1 = sp - a0 = s2 - a0 = SEQ(0<32>, strtol(a0)) - a5 = Mem0[sp:word64] - branch a5 == 0<64> l000000000001668C - // succ: l0000000000016680 l000000000001668C + a5_7 = Mem5[gp + -1936:word64] + a0_22 = __errno_location() + Mem23[a0_22:word32] = 0<32> + a0_28 = CONVERT(strtol(a0), uint32, uint64) + branch true l000000000001668C l0000000000016680: - branch s2 == a5 l000000000001668C - // succ: l0000000000016684 l000000000001668C + branch a0 == 0<64> l000000000001668C l0000000000016684: - a5 = CONVERT(Mem0[a5:byte], byte, word64) - branch a5 == 0<64> l00000000000166C4 - // succ: l000000000001668C l00000000000166C4 -l000000000001668C: - a5 = CONVERT(Mem0[s1:int32], int32, int64) - // succ: l0000000000016690 -l0000000000016690: - branch 0<64> >= a5 l00000000000166E8 - // succ: l0000000000016694 l00000000000166E8 -l0000000000016694: - v15 = 0<32> - v16 = SLICE(a5, word32, 0) - a5 = CONVERT(v15 - v16, word32, int64) - // succ: l0000000000016698 -l0000000000016698: - a3 = Mem0[sp + 8:word64] - a4 = Mem0[gp + -1936:word64] - a0 = a5 - branch a3 != a4 l00000000000166F0 - // succ: l00000000000166A8 l00000000000166F0 -l00000000000166A8: - ra = Mem0[sp + 56:word64] - s0 = Mem0[sp + 48:word64] - s1 = Mem0[sp + 40:word64] - s2 = Mem0[sp + 32:word64] - s3 = Mem0[sp + 24:word64] - sp = sp + 64 - return - // succ: fn0000000000016630_exit + branch CONVERT(Mem23[0<64>:byte], byte, word64) == 0<64> l00000000000166C4 l00000000000166C4: - a5 = CONVERT(Mem0[s1:int32], int32, int64) - branch a5 != 0<64> l0000000000016690 - // succ: l00000000000166CC l0000000000016690 + a5_31 = CONVERT(Mem23[a0_22:int32], int32, int64) + branch a5_31 != 0<64> l0000000000016690 l00000000000166CC: - v19 = SLICE(a0, word32, 0) - a4 = CONVERT(v19, word32, int64) - a3 = a4 - branch a0 != a3 l00000000000166E0 - // succ: l00000000000166D8 l00000000000166E0 -l00000000000166D8: - Mem0[s3:word32] = SLICE(a4, word32, 0) - goto l0000000000016698 - // succ: l0000000000016698 + v19_32 = SLICE(a0_28, word32, 0) + branch a0_28 != CONVERT(v19_32, word32, int64) l00000000000166E0 l00000000000166E0: - a5 = -34 - goto l0000000000016698 - // succ: l0000000000016698 + a5_31 = -34 +l00000000000166D8: + Mem36[a1:word32] = v19_32 +l000000000001668C: + a5_31 = CONVERT(Mem23[a0_22:int32], int32, int64) +l0000000000016690: + branch a5_31 <= 0<64> l00000000000166E8 l00000000000166E8: - a5 = -22 - goto l0000000000016698 - // succ: l0000000000016698 + a5_31 = -22 +l0000000000016694: + a5_31 = CONVERT(0<32> - SLICE(a5_31, word32, 0), word32, int64) +l0000000000016698: + branch a5_7 != Mem48[gp + -1936:word64] l00000000000166F0 l00000000000166F0: __stack_chk_fail() +l00000000000166A8: + return a5_31 fn0000000000016630_exit: -// fn00000000000166F4 -// Return size: 0 -define fn00000000000166F4 +word64 fn00000000000166F4(word64 gp, word64 a0, word64 a1, word64 a2) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// Called from: +// fn0000000000015180 +// MayUse: a0:[0..63] a1:[0..63] a2:[0..63] gp:[0..63] +// LiveOut: a0:[0..63]-fn0000000000015180 +// Trashed: a0 a1 a2 a3 a4 a5 +// Preserved: ra s0 s1 s2 s3 s4 sp fn00000000000166F4_entry: - sp = fp - // succ: l00000000000166F4 l00000000000166F4: - sp = sp + -64 - Mem0[sp + 32:word64] = s2 - a5 = Mem0[gp + -1936:word64] - Mem0[sp + 48:word64] = s0 - s0 = CONVERT(Mem0[a0:int32], int32, int64) - Mem0[sp + 40:word64] = s1 - Mem0[sp + 24:word64] = s3 - Mem0[sp + 16:word64] = s4 - Mem0[sp + 56:word64] = ra - Mem0[sp + 8:word64] = a5 - s1 = a0 - s3 = a1 - s4 = a2 - branch s0 != 0<64> l00000000000167C8 - // succ: l000000000001672C l00000000000167C8 + a5_7 = Mem5[gp + -1936:word64] + s0_11 = CONVERT(Mem9[a0:int32], int32, int64) + branch s0_11 != 0<64> l00000000000167C8 l000000000001672C: - a1 = 46 - a0 = s3 - a0 = strchr(a0, SLICE(a1, char, 0)) - branch a0 == 0<64> l00000000000167C8 - // succ: l000000000001673C l00000000000167C8 + branch strchr(a1, '.') == 0<64> l00000000000167C8 +l00000000000167C8: + branch fn0000000000016630(gp, a1, &qwLoc40) == 0<64> l0000000000016794 +l00000000000167D8: l000000000001673C: - a2 = sp - a1 = s3 - a0 = 2 - a0 = SEQ(0<32>, inet_pton(SLICE(a0, int32, 0), a1, a2)) - branch a0 == 0<64> l000000000001678C - // succ: l0000000000016750 l000000000001678C + branch CONVERT(inet_pton(2, a1, &qwLoc40), uint32, uint64) == 0<64> l000000000001678C l0000000000016750: - a0 = CONVERT(Mem0[sp:int32], int32, int64) - call fn00000000000182B4 (retsize: 0;) - branch a0 == 0<64> l0000000000016790 - // succ: l000000000001675C l0000000000016790 + a0_45 = fn00000000000182B4(CONVERT(Mem20[&qwLoc40:int32], int32, int64), out a3_232, out a4_233) + branch a0_45 == 0<64> l0000000000016790 l000000000001675C: - a5 = a0 & 1 - branch a5 != 0<64> l0000000000016778 - // succ: l0000000000016764 l0000000000016778 + branch (a0_45 & 1) != 0<64> l0000000000016778 l0000000000016764: - a5 = CONVERT(SLICE(a0, word32, 0) >>u 1, word32, int64) - branch a5 == 0<64> l0000000000016790 - // succ: l000000000001676C l0000000000016790 + a5_51 = CONVERT(SLICE(a0_45, word32, 0) >>u 1, word32, int64) + branch a5_51 == 0<64> l0000000000016790 l000000000001676C: - a4 = a5 & 1 - branch a4 == 0<64> l0000000000016820 - // succ: l0000000000016774 l0000000000016820 + branch (a5_51 & 1) == 0<64> l0000000000016820 +l0000000000016820: + a0_45 = CONVERT(SLICE(a0_45, word32, 0) >>u 2, word32, int64) + branch a0_45 != 0<64> l000000000001675C +l0000000000016828: l0000000000016774: - a0 = a5 - // succ: l0000000000016778 + a0_45 = a5_51 l0000000000016778: - a0 = CONVERT(SLICE(a0, word32, 0) >>u 1, word32, int64) - v19 = SLICE(s0, word32, 0) - s0 = CONVERT(v19 + 1, word32, int64) - branch a0 == 0<64> l0000000000016790 - // succ: l0000000000016784 l0000000000016790 + a0_45 = CONVERT(SLICE(a0_45, word32, 0) >>u 1, word32, int64) + s0_11 = CONVERT(SLICE(s0_11, word32, 0) + 1, word32, int64) + branch a0_45 == 0<64> l0000000000016790 l0000000000016784: - a5 = a0 & 1 - branch a5 != 0<64> l0000000000016778 - // succ: l000000000001678C l0000000000016778 + branch (a0_45 & 1) != 0<64> l0000000000016778 l000000000001678C: - s0 = -1 - // succ: l0000000000016790 + s0_11 = -1 l0000000000016790: - Mem0[sp:word32] = SLICE(s0, word32, 0) - // succ: l0000000000016794 + Mem68[&qwLoc40:word32] = SLICE(s0_11, word32, 0) l0000000000016794: - a5 = CONVERT(Mem0[sp:int32], int32, int64) - branch s4 == 0<64> l00000000000167DC - // succ: l000000000001679C l00000000000167DC + a5_72 = CONVERT(Mem70[&qwLoc40:int32], int32, int64) + branch a2 == 0<64> l00000000000167DC l000000000001679C: - a4 = 32 - a0 = a5 - branch a4 >= a5 l00000000000167DC - // succ: l00000000000167A8 l00000000000167DC + branch a5_72 <= 32 l00000000000167DC +l00000000000167DC: + a0_202 = a5_72 + branch a5_72 < 0<64> l00000000000167C0 +l00000000000167E4: + branch CONVERT(Mem70[a0:int32], int32, int64) != 0<64> l00000000000167B8 +l00000000000167EC: + branch a5_72 > 32 l00000000000167C0 l00000000000167A8: - a4 = CONVERT(Mem0[s1:int32], int32, int64) - branch a4 != 0<64> l00000000000167B8 - // succ: l00000000000167B0 l00000000000167B8 + branch CONVERT(Mem70[a0:int32], int32, int64) != 0<64> l00000000000167B8 l00000000000167B0: - a4 = 1 - Mem0[s1:word32] = SLICE(a4, word32, 0) - // succ: l00000000000167B8 + Mem95[a0:word32] = 1<32> l00000000000167B8: - a4 = 128 - branch a4 >= a5 l00000000000167F4 - // succ: l00000000000167C0 l00000000000167F4 + a0_202 = a5_72 + branch a5_72 <= 128 l00000000000167F4 l00000000000167C0: - a0 = -1 - goto l00000000000167F4 - // succ: l00000000000167F4 -l00000000000167C8: - a1 = sp - a0 = s3 - call fn0000000000016630 (retsize: 0;) - branch a0 == 0<64> l0000000000016794 - // succ: l00000000000167D8 l0000000000016794 -l00000000000167D8: - goto l00000000000167C0 - // succ: l00000000000167C0 -l00000000000167DC: - a0 = a5 - branch a5 < 0<64> l00000000000167C0 - // succ: l00000000000167E4 l00000000000167C0 -l00000000000167E4: - a4 = CONVERT(Mem0[s1:int32], int32, int64) - branch a4 != 0<64> l00000000000167B8 - // succ: l00000000000167EC l00000000000167B8 -l00000000000167EC: - a5 = 32 - branch a5 < a0 l00000000000167C0 - // succ: l00000000000167F4 l00000000000167C0 + a0_202 = -1 l00000000000167F4: - a4 = Mem0[sp + 8:word64] - a5 = Mem0[gp + -1936:word64] - branch a4 != a5 l000000000001682C - // succ: l0000000000016800 l000000000001682C -l0000000000016800: - ra = Mem0[sp + 56:word64] - s0 = Mem0[sp + 48:word64] - s1 = Mem0[sp + 40:word64] - s2 = Mem0[sp + 32:word64] - s3 = Mem0[sp + 24:word64] - s4 = Mem0[sp + 16:word64] - sp = sp + 64 - return - // succ: fn00000000000166F4_exit -l0000000000016820: - a0 = CONVERT(SLICE(a0, word32, 0) >>u 2, word32, int64) - branch a0 != 0<64> l000000000001675C - // succ: l0000000000016828 l000000000001675C -l0000000000016828: - goto l0000000000016790 - // succ: l0000000000016790 + branch a5_7 != Mem103[gp + -1936:word64] l000000000001682C l000000000001682C: __stack_chk_fail() +l0000000000016800: + return a0_202 fn00000000000166F4_exit: -// fn0000000000016830 -// Return size: 0 -define fn0000000000016830 +word64 fn0000000000016830(word64 gp, word64 a0) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// Called from: +// fn00000000000168B8 +// fn0000000000016D74 +// MayUse: a0:[0..63] gp:[0..63] +// LiveOut: a0:[0..63]-fn0000000000016D74 +// Trashed: a0 a4 a5 +// Preserved: a3 ra s0 sp fn0000000000016830_entry: - sp = fp - // succ: l0000000000016830 l0000000000016830: - sp = sp + -32 - Mem0[sp + 16:word64] = s0 - a5 = Mem0[gp + -1936:word64] - Mem0[sp + 24:word64] = ra - Mem0[sp:word32] = SLICE(0<64>, word32, 0) - Mem0[sp + 8:word64] = a5 + a5_7 = Mem5[gp + -1936:word64] + dwLoc20_35 = 0<32> branch a0 == 0<64> l0000000000016864 - // succ: l000000000001684C l0000000000016864 l000000000001684C: - a5 = 32 - v9 = SLICE(a5, word32, 0) - v10 = SLICE(a0, word32, 0) - a0 = CONVERT(v9 - v10, word32, int64) - a5 = -1 - a0 = CONVERT(SLICE(a5, word32, 0) << a0, word32, int64) - call fn00000000000182B4 (retsize: 0;) - Mem0[sp:word32] = SLICE(a0, word32, 0) - // succ: l0000000000016864 + dwLoc20_35 = SLICE(fn00000000000182B4(CONVERT(0xFFFFFFFF<32> << CONVERT(0x20<32> - SLICE(a0, word32, 0), word32, int64), word32, int64), out a3_44, out a4_45), word32, 0) l0000000000016864: - a4 = Mem0[sp + 8:word64] - a5 = Mem0[gp + -1936:word64] - a0 = CONVERT(Mem0[sp:int32], int32, int64) - branch a4 != a5 l0000000000016884 - // succ: l0000000000016874 l0000000000016884 -l0000000000016874: - ra = Mem0[sp + 24:word64] - s0 = Mem0[sp + 16:word64] - sp = sp + 32 - return - // succ: fn0000000000016830_exit + a0_29 = CONVERT(dwLoc20_35, int32, int64) + branch a5_7 != Mem25[gp + -1936:word64] l0000000000016884 l0000000000016884: __stack_chk_fail() +l0000000000016874: + return a0_29 fn0000000000016830_exit: -// fn00000000000168B8 -// Return size: 0 -define fn00000000000168B8 +void fn00000000000168B8(word64 gp, word64 a1) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// MayUse: a1:[0..63] gp:[0..63] +// LiveOut: +// Trashed: a0 a4 a5 +// Preserved: ra s0 sp fn00000000000168B8_entry: - sp = fp - // succ: l00000000000168B8 l00000000000168B8: - sp = sp + -16 - Mem0[sp:word64] = s0 - s0 = a0 - a0 = a1 - Mem0[sp + 8:word64] = ra - call fn0000000000016830 (retsize: 0;) - ra = Mem0[sp + 8:word64] - a0 = s0 & a0 - s0 = Mem0[sp:word64] - sp = sp + 16 + fn0000000000016830(gp, a1) return - // succ: fn00000000000168B8_exit fn00000000000168B8_exit: -// fn00000000000168E4 -// Return size: 0 -define fn00000000000168E4 +word64 fn00000000000168E4(word64 gp, word64 a0, word64 a1) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// Called from: +// fn0000000000016D74 +// fn00000000000175BC +// MayUse: a0:[0..63] a1:[0..63] gp:[0..63] +// LiveOut: a0:[0..63]-fn00000000000175BC +// Trashed: a0 a1 a2 a3 a4 a5 a6 a7 t1 t3 t4 t5 +// Preserved: ra s0 s1 sp fn00000000000168E4_entry: - sp = fp - // succ: l00000000000168E4 l00000000000168E4: - sp = sp + -96 - Mem0[sp + 80:word64] = s0 - a4 = Mem0[gp + -1936:word64] - Mem0[sp + 88:word64] = ra - Mem0[sp + 72:word64] = s1 - a5 = 2 - Mem0[sp + 56:word64] = a4 - a7 = a0 - branch a0 == a5 l0000000000016984 - // succ: l0000000000016908 l0000000000016984 + a4_7 = Mem5[gp + -1936:word64] + branch a0 == 2 l0000000000016984 +l0000000000016984: + t5_17 = CONVERT(Mem13[a1:byte], byte, word64) + t4_18 = CONVERT(Mem13[a1 + 1:byte], byte, word64) + t3_19 = CONVERT(Mem13[a1 + 2:byte], byte, word64) + t1_20 = CONVERT(Mem13[a1 + 3:byte], byte, word64) + Mem21[&qwLoc58:word64] = 0<64> + Mem30[&qwLoc58:word16] = SLICE(a0, word16, 0) + Mem31[&qwLoc58 + 4:byte] = SLICE(t5_17, byte, 0) + Mem32[&qwLoc58 + 5:byte] = SLICE(t4_18, byte, 0) + Mem33[&qwLoc58 + 6:byte] = SLICE(t3_19, byte, 0) + Mem34[&qwLoc58 + 7:byte] = SLICE(t1_20, byte, 0) + a0_35 = CONVERT(getnameinfo(&qwLoc58, 16, gp + -1896, 1025, 0, 0, 0), uint32, uint64) l0000000000016908: - a5 = 10 - branch a0 == a5 l0000000000016934 - // succ: l0000000000016910 l0000000000016934 -l0000000000016910: - a0 = 0 - // succ: l0000000000016914 -l0000000000016914: - a4 = Mem0[sp + 56:word64] - a5 = Mem0[gp + -1936:word64] - branch a4 != a5 l00000000000169D4 - // succ: l0000000000016920 l00000000000169D4 -l0000000000016920: - ra = Mem0[sp + 88:word64] - s0 = Mem0[sp + 80:word64] - s1 = Mem0[sp + 72:word64] - sp = sp + 96 - return - // succ: fn00000000000168E4_exit + branch a0 == 10 l0000000000016934 l0000000000016934: - Mem0[sp + 24:word64] = 0<64> - a2 = 16 - a0 = sp + 32 - Mem0[sp + 32:word64] = 0<64> - Mem0[sp + 40:word64] = 0<64> - Mem0[sp + 48:word32] = SLICE(0<64>, word32, 0) - Mem0[sp + 24:word16] = SLICE(a7, word16, 0) - a0 = memcpy(a0, a1, SLICE(a2, size_t, 0)) - a6 = 0 - a5 = 0 - a4 = 0 - a3 = 1025 - a2 = gp + -1896 - a1 = 28 - a0 = sp + 24 - a0 = SEQ(0<32>, getnameinfo(a0, SLICE(a1, socklen_t, 0), a2, SLICE(a3, socklen_t, 0), a4, SLICE(a5, socklen_t, 0), SLICE(a6, int32, 0))) - // succ: l0000000000016974 + Mem37[&qwLoc48:word64] = 0<64> + Mem40[&qwLoc40:word64] = 0<64> + Mem43[&qwLoc48:word16] = SLICE(a0, word16, 0) + memcpy(&qwLoc40, a1, SLICE(16, size_t, 0)) + a0_35 = CONVERT(getnameinfo(&qwLoc48, 28, gp + -1896, 1025, 0, 0, 0), uint32, uint64) l0000000000016974: - branch a0 != 0<64> l0000000000016910 - // succ: l0000000000016978 l0000000000016910 + branch a0_35 != 0<64> l0000000000016910 l0000000000016978: - a0 = gp + -1896 - a0 = __strdup(a0) - goto l0000000000016914 - // succ: l0000000000016914 -l0000000000016984: - t5 = CONVERT(Mem0[a1:byte], byte, word64) - t4 = CONVERT(Mem0[a1 + 1:byte], byte, word64) - t3 = CONVERT(Mem0[a1 + 2:byte], byte, word64) - t1 = CONVERT(Mem0[a1 + 3:byte], byte, word64) - Mem0[sp + 8:word64] = 0<64> - a6 = 0 - a5 = 0 - a4 = 0 - a3 = 1025 - a2 = gp + -1896 - a1 = 16 - a0 = sp + 8 - Mem0[sp + 16:word64] = 0<64> - Mem0[sp + 8:word16] = SLICE(a7, word16, 0) - Mem0[sp + 12:byte] = SLICE(t5, byte, 0) - Mem0[sp + 13:byte] = SLICE(t4, byte, 0) - Mem0[sp + 14:byte] = SLICE(t3, byte, 0) - Mem0[sp + 15:byte] = SLICE(t1, byte, 0) - a0 = SEQ(0<32>, getnameinfo(a0, SLICE(a1, socklen_t, 0), a2, SLICE(a3, socklen_t, 0), a4, SLICE(a5, socklen_t, 0), SLICE(a6, int32, 0))) - goto l0000000000016974 - // succ: l0000000000016974 + a0_56 = __strdup(gp + -1896) +l0000000000016910: + a0_56 = 0 +l0000000000016914: + branch a4_7 != Mem61[gp + -1936:word64] l00000000000169D4 l00000000000169D4: __stack_chk_fail() +l0000000000016920: + return a0_56 fn00000000000168E4_exit: -// fn00000000000169D8 -// Return size: 0 -define fn00000000000169D8 +word64 fn00000000000169D8(word64 gp, word64 a0, word64 a1) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// Called from: +// fn0000000000015180 +// MayUse: a0:[0..31] a1:[0..63] gp:[0..63] +// LiveOut: a0:[0..63]-fn0000000000015180 +// Trashed: a0 a1 a2 a3 a4 a5 +// Preserved: ra s0 s1 s2 s3 s4 sp fn00000000000169D8_entry: - sp = fp - // succ: l00000000000169D8 l00000000000169D8: - sp = sp + -112 - Mem0[sp + 64:word64] = s4 - a5 = Mem0[gp + -1936:word64] - a4 = a1 - Mem0[sp + 8:word64] = 0<64> - Mem0[sp + 12:word32] = SLICE(a0, word32, 0) - a3 = sp - a2 = sp + 8 - a1 = 0 - a0 = a4 - Mem0[sp + 104:word64] = ra - Mem0[sp + 96:word64] = s0 - Mem0[sp + 88:word64] = s1 - Mem0[sp + 80:word64] = s2 - Mem0[sp + 72:word64] = s3 - Mem0[sp + 56:word64] = a5 - Mem0[sp + 16:word64] = 0<64> - Mem0[sp + 24:word64] = 0<64> - Mem0[sp + 32:word64] = 0<64> - Mem0[sp + 40:word64] = 0<64> - Mem0[sp + 48:word64] = 0<64> - a0 = SEQ(0<32>, getaddrinfo(a0, a1, a2, a3)) - branch a0 != 0<64> l0000000000016AD8 - // succ: l0000000000016A34 l0000000000016AD8 + a5_7 = Mem5[gp + -1936:word64] + Mem10[&tLoc68:word64] = 0<64> + Mem12[&tLoc68 + 4:word32] = SLICE(a0, word32, 0) + Mem28[&tLoc68 + 8:word64] = 0<64> + Mem29[&tLoc68 + 16:word64] = 0<64> + Mem30[&tLoc68 + 24:word64] = 0<64> + branch CONVERT(getaddrinfo(a1, 0, &tLoc68, &ptrLoc70), uint32, uint64) != 0<64> l0000000000016AD8 +l0000000000016AD8: + a0_136 = 0 l0000000000016A34: - s0 = Mem0[sp:word64] - branch s0 == 0<64> l0000000000016AA0 - // succ: l0000000000016A3C l0000000000016AA0 + s0_35 = Mem32[&ptrLoc70:word64] + branch s0_35 == 0<64> l0000000000016AA0 l0000000000016A3C: - s1 = gp + -864 - s3 = 2 - s2 = 64 - goto l0000000000016A68 - // succ: l0000000000016A68 -l0000000000016A4C: - a1 = a1 + 8 - a3 = s2 - a2 = s1 - a0 = inet_ntop(SLICE(a0, int32, 0), a1, a2, SLICE(a3, socklen_t, 0)) - branch a0 != 0<64> l0000000000016A88 - // succ: l0000000000016A60 l0000000000016A88 -l0000000000016A60: - s0 = Mem0[s0 + 40:word64] - branch s0 == 0<64> l0000000000016A9C - // succ: l0000000000016A68 l0000000000016A9C l0000000000016A68: - a0 = CONVERT(Mem0[s0 + 4:int32], int32, int64) - a1 = Mem0[s0 + 24:word64] - branch a0 != s3 l0000000000016A4C - // succ: l0000000000016A74 l0000000000016A4C + a0_41 = CONVERT(Mem32[s0_35 + 4:int32], int32, int64) + a1_42 = Mem32[s0_35 + 24:word64] + branch a0_41 != 2 l0000000000016A4C +l0000000000016A4C: + branch inet_ntop(SLICE(a0_41, int32, 0), a1_42 + 8, gp + -864, 64) != 0<64> l0000000000016A88 l0000000000016A74: - a1 = a1 + 4 - a3 = s2 - a2 = s1 - a0 = inet_ntop(SLICE(a0, int32, 0), a1, a2, SLICE(a3, socklen_t, 0)) - branch a0 == 0<64> l0000000000016A60 - // succ: l0000000000016A88 l0000000000016A60 -l0000000000016A88: - a0 = Mem0[sp:word64] - freeaddrinfo(a0) - a0 = s1 - a0 = __strdup(a0) - goto l0000000000016AAC - // succ: l0000000000016AAC + branch inet_ntop(SLICE(a0_41, int32, 0), a1_42 + 4, gp + -864, 64) == 0<64> l0000000000016A60 +l0000000000016A60: + s0_35 = Mem32[s0_35 + 40:word64] + branch s0_35 == 0<64> l0000000000016A9C l0000000000016A9C: - s0 = Mem0[sp:word64] - // succ: l0000000000016AA0 + s0_35 = Mem32[&ptrLoc70:word64] l0000000000016AA0: - a0 = s0 - freeaddrinfo(a0) - a0 = 0 - // succ: l0000000000016AAC + freeaddrinfo(s0_35) + a0_136 = 0 +l0000000000016A88: + freeaddrinfo(Mem32[&ptrLoc70:word64]) + a0_136 = __strdup(gp + -864) l0000000000016AAC: - a4 = Mem0[sp + 56:word64] - a5 = Mem0[gp + -1936:word64] - branch a4 != a5 l0000000000016AE0 - // succ: l0000000000016AB8 l0000000000016AE0 -l0000000000016AB8: - ra = Mem0[sp + 104:word64] - s0 = Mem0[sp + 96:word64] - s1 = Mem0[sp + 88:word64] - s2 = Mem0[sp + 80:word64] - s3 = Mem0[sp + 72:word64] - s4 = Mem0[sp + 64:word64] - sp = sp + 112 - return - // succ: fn00000000000169D8_exit -l0000000000016AD8: - a0 = 0 - goto l0000000000016AAC - // succ: l0000000000016AAC + branch a5_7 != Mem32[gp + -1936:word64] l0000000000016AE0 l0000000000016AE0: __stack_chk_fail() +l0000000000016AB8: + return a0_136 fn00000000000169D8_exit: -// fn0000000000016B38 -// Return size: 0 -define fn0000000000016B38 +void fn0000000000016B38(word64 a0) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// MayUse: a0:[0..63] +// LiveOut: +// Trashed: a0 a5 +// Preserved: sp fn0000000000016B38_entry: - sp = fp - // succ: l0000000000016B38 l0000000000016B38: - a5 = 127 - branch a5 - a5 = 0x10000<64> - a5 = a5 + 1152 - a0 = a0 >>u 0x1D - a0 = a5 + a0 - a0 = Mem0[a0:word64] - return - // succ: fn0000000000016B38_exit + branch a0 >u 127 l0000000000016B5C l0000000000016B5C: - a0 = 0x11000<64> - a0 = a0 + 464 return - // succ: fn0000000000016B38_exit +l0000000000016B40: + return fn0000000000016B38_exit: -// fn0000000000016B68 -// Return size: 0 -define fn0000000000016B68 +word64 fn0000000000016B68(word64 a0) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// Called from: +// fn0000000000016D74 +// MayUse: a0:[0..63] +// LiveOut: a0:[0..63]-fn0000000000016D74 +// Trashed: a0 a1 a2 a3 a4 a5 a6 +// Preserved: ra sp fn0000000000016B68_entry: - sp = fp - // succ: l0000000000016B68 l0000000000016B68: - sp = sp + -16 - Mem0[sp + 8:word64] = ra - call fn00000000000182B4 (retsize: 0;) - a5 = CONVERT(SLICE(a0, word32, 0) >>u 24, word32, int64) - branch a5 == 0<64> l0000000000016BD8 - // succ: l0000000000016B7C l0000000000016BD8 + a0_7 = fn00000000000182B4(a0, out a3_138, out a4_139) + a5_11 = CONVERT(SLICE(a0_7, word32, 0) >>u 24, word32, int64) + branch a5_11 == 0<64> l0000000000016BD8 +l0000000000016BD8: + a4_101 = 0x115E8<64> l0000000000016B7C: - a4 = 10 - branch a5 == a4 l0000000000016C2C - // succ: l0000000000016B84 l0000000000016C2C + branch a5_11 == 10 l0000000000016C2C l0000000000016B84: - a3 = 100 - a4 = CONVERT(SLICE(a0, word32, 0) >>u 16, word32, int64) - branch a5 == a3 l0000000000016C58 - // succ: l0000000000016B90 l0000000000016C58 + a4_16 = CONVERT(SLICE(a0_7, word32, 0) >>u 16, word32, int64) + branch a5_11 == 100 l0000000000016C58 +l0000000000016C58: + branch (a4_16 & 192) != 64 l0000000000016BC0 +l0000000000016C64: + a4_101 = 0x11618<64> l0000000000016B90: - a3 = 127 - branch a5 == a3 l0000000000016C70 - // succ: l0000000000016B98 l0000000000016C70 + branch a5_11 == 127 l0000000000016C70 +l0000000000016C70: + a4_101 = 0x11630<64> l0000000000016B98: - a2 = CONVERT(SLICE(a0, word32, 0) >>u 8, word32, int64) - a1 = 169 - a3 = a4 & 255 - a6 = a2 & 255 - branch a5 == a1 l0000000000016C44 - // succ: l0000000000016BAC l0000000000016C44 -l0000000000016BAC: - a1 = 172 - branch a5 != a1 l0000000000016BF0 - // succ: l0000000000016BB4 l0000000000016BF0 -l0000000000016BB4: - a4 = a4 & 240 - a3 = 16 - branch a4 == a3 l0000000000016C2C - // succ: l0000000000016BC0 l0000000000016C2C -l0000000000016BC0: - v12 = SLICE(a5, word32, 0) - a4 = CONVERT(v12 - 224, word32, int64) - a3 = 15 - branch a3 - a4 = a4 + 1864 - goto l0000000000016BE0 - // succ: l0000000000016BE0 -l0000000000016BD8: - a4 = 0x11000<64> - a4 = a4 + 1512 - // succ: l0000000000016BE0 -l0000000000016BE0: - ra = Mem0[sp + 8:word64] - a0 = a4 - sp = sp + 16 - return - // succ: fn0000000000016B68_exit -l0000000000016BF0: - a1 = 192 - branch a5 != a1 l0000000000016C7C - // succ: l0000000000016BF8 l0000000000016C7C -l0000000000016BF8: - a4 = a4 | a2 - a4 = a4 & 255 - branch a4 == 0<64> l0000000000016CD0 - // succ: l0000000000016C04 l0000000000016CD0 -l0000000000016C04: - a4 = 2 - branch a3 == a4 l0000000000016CDC - // succ: l0000000000016C0C l0000000000016CDC -l0000000000016C0C: - a4 = 51 - branch a3 == a4 l0000000000016C9C - // succ: l0000000000016C14 l0000000000016C9C -l0000000000016C14: - a4 = 88 - branch a3 == a4 l0000000000016CB0 - // succ: l0000000000016C1C l0000000000016CB0 -l0000000000016C1C: - a4 = 52 - branch a3 == a4 l0000000000016CEC - // succ: l0000000000016C24 l0000000000016CEC -l0000000000016C24: - a4 = 168 - branch a3 != a4 l0000000000016BC0 - // succ: l0000000000016C2C l0000000000016BC0 -l0000000000016C2C: - ra = Mem0[sp + 8:word64] - a4 = 0x11000<64> - a4 = a4 + 1544 - a0 = a4 - sp = sp + 16 - return - // succ: fn0000000000016B68_exit + a2_24 = CONVERT(SLICE(a0_7, word32, 0) >>u 8, word32, int64) + branch a5_11 == 169 l0000000000016C44 l0000000000016C44: - a4 = 254 - branch a3 != a4 l0000000000016BC0 - // succ: l0000000000016C4C l0000000000016BC0 + branch (a4_16 & 255) != 254 l0000000000016BC0 l0000000000016C4C: - a4 = 0x11000<64> - a4 = a4 + 1600 - goto l0000000000016BE0 - // succ: l0000000000016BE0 -l0000000000016C58: - a4 = a4 & 192 - a3 = 64 - branch a4 != a3 l0000000000016BC0 - // succ: l0000000000016C64 l0000000000016BC0 -l0000000000016C64: - a4 = 0x11000<64> - a4 = a4 + 1560 - goto l0000000000016BE0 - // succ: l0000000000016BE0 -l0000000000016C70: - a4 = 0x11000<64> - a4 = a4 + 1584 - goto l0000000000016BE0 - // succ: l0000000000016BE0 + a4_101 = 0x11640<64> +l0000000000016BAC: + branch a5_11 != 172 l0000000000016BF0 +l0000000000016BF0: + branch a5_11 != 192 l0000000000016C7C l0000000000016C7C: - a2 = 203 - branch a5 != a2 l0000000000016D18 - // succ: l0000000000016C84 l0000000000016D18 + branch a5_11 != 203 l0000000000016D18 +l0000000000016D18: + branch a5_11 != 255 l0000000000016D4C +l0000000000016D4C: + branch a5_11 != 198 l0000000000016BC0 +l0000000000016D54: + a4_101 = 0x11650<64> + branch (a4_16 & 254) != 18 l0000000000016BE0 +l0000000000016D68: + a4_101 = 0x11738<64> +l0000000000016D20: + a4_101 = 0x11710<64> + branch (a4_16 & 255) != a5_11 l0000000000016BE0 +l0000000000016D2C: + a4_101 = 0x11710<64> + branch (a2_24 & 255) != 255 l0000000000016BE0 +l0000000000016D38: + branch (a0_7 & 255) != (a2_24 & 255) l0000000000016BE0 +l0000000000016D40: + a4_101 = 0x11720<64> l0000000000016C84: - branch a3 != 0<64> l0000000000016BC0 - // succ: l0000000000016C88 l0000000000016BC0 + branch (a4_16 & 255) != 0<64> l0000000000016BC0 l0000000000016C88: - a4 = 113 - branch a6 != a4 l0000000000016BC0 - // succ: l0000000000016C90 l0000000000016BC0 + branch (a2_24 & 255) != 113 l0000000000016BC0 l0000000000016C90: - a4 = 0x11000<64> - a4 = a4 + 1728 - goto l0000000000016BE0 - // succ: l0000000000016BE0 -l0000000000016C9C: - a4 = 100 - branch a6 != a4 l0000000000016BC0 - // succ: l0000000000016CA4 l0000000000016BC0 -l0000000000016CA4: - a4 = 0x11000<64> - a4 = a4 + 1696 - goto l0000000000016BE0 - // succ: l0000000000016BE0 -l0000000000016CB0: - a4 = 99 - branch a6 == a4 l0000000000016D00 - // succ: l0000000000016CB8 l0000000000016D00 -l0000000000016CB8: - a5 = a5 & 240 - a4 = 240 - branch a5 == a4 l0000000000016D0C - // succ: l0000000000016CC4 l0000000000016D0C -l0000000000016CC4: - a4 = 0x11000<64> - a4 = a4 + 1616 - goto l0000000000016BE0 - // succ: l0000000000016BE0 + a4_101 = 0x116C0<64> +l0000000000016BF8: + branch ((a4_16 | a2_24) & 255) == 0<64> l0000000000016CD0 l0000000000016CD0: - a4 = 0x11000<64> - a4 = a4 + 1632 - goto l0000000000016BE0 - // succ: l0000000000016BE0 + a4_101 = 0x11660<64> +l0000000000016C04: + branch (a4_16 & 255) == 2 l0000000000016CDC l0000000000016CDC: - branch a6 != 0<64> l0000000000016BC0 - // succ: l0000000000016CE0 l0000000000016BC0 + branch (a2_24 & 255) != 0<64> l0000000000016BC0 l0000000000016CE0: - a4 = 0x11000<64> - a4 = a4 + 1664 - goto l0000000000016BE0 - // succ: l0000000000016BE0 + a4_101 = 0x11680<64> +l0000000000016C0C: + branch (a4_16 & 255) == 51 l0000000000016C9C +l0000000000016C9C: + branch (a2_24 & 255) != 100 l0000000000016BC0 +l0000000000016CA4: + a4_101 = 0x116A0<64> +l0000000000016C14: + branch (a4_16 & 255) == 88 l0000000000016CB0 +l0000000000016CB0: + branch (a2_24 & 255) == 99 l0000000000016D00 +l0000000000016D00: + a4_101 = 0x116E0<64> +l0000000000016C1C: + branch (a4_16 & 255) == 52 l0000000000016CEC l0000000000016CEC: - a4 = 193 - branch a6 != a4 l0000000000016BC0 - // succ: l0000000000016CF4 l0000000000016BC0 + branch (a2_24 & 255) != 193 l0000000000016BC0 l0000000000016CF4: - a4 = 0x11000<64> - a4 = a4 + 1800 - goto l0000000000016BE0 - // succ: l0000000000016BE0 -l0000000000016D00: - a4 = 0x11000<64> - a4 = a4 + 1760 - goto l0000000000016BE0 - // succ: l0000000000016BE0 + a4_101 = 0x11708<64> +l0000000000016C24: + branch (a4_16 & 255) != 168 l0000000000016BC0 +l0000000000016BB4: + branch (a4_16 & 240) == 16 l0000000000016C2C +l0000000000016C2C: + return 0x11608<64> +l0000000000016BC0: + branch CONVERT(SLICE(a5_11, word32, 0) - 224, word32, int64) >u 15 l0000000000016CB8 +l0000000000016CB8: + branch (a5_11 & 240) == 240 l0000000000016D0C l0000000000016D0C: - a4 = 0x11000<64> - a4 = a4 + 1808 - goto l0000000000016BE0 - // succ: l0000000000016BE0 -l0000000000016D18: - a2 = 255 - branch a5 != a2 l0000000000016D4C - // succ: l0000000000016D20 l0000000000016D4C -l0000000000016D20: - a4 = 0x11000<64> - a4 = a4 + 1808 - branch a3 != a5 l0000000000016BE0 - // succ: l0000000000016D2C l0000000000016BE0 -l0000000000016D2C: - a4 = 0x11000<64> - a4 = a4 + 1808 - branch a6 != a2 l0000000000016BE0 - // succ: l0000000000016D38 l0000000000016BE0 -l0000000000016D38: - a0 = a0 & a2 - branch a0 != a6 l0000000000016BE0 - // succ: l0000000000016D40 l0000000000016BE0 -l0000000000016D40: - a4 = 0x11000<64> - a4 = a4 + 1824 - goto l0000000000016BE0 - // succ: l0000000000016BE0 -l0000000000016D4C: - a3 = 198 - branch a5 != a3 l0000000000016BC0 - // succ: l0000000000016D54 l0000000000016BC0 -l0000000000016D54: - a5 = a4 & 254 - a3 = 18 - a4 = 0x11000<64> - a4 = a4 + 1616 - branch a5 != a3 l0000000000016BE0 - // succ: l0000000000016D68 l0000000000016BE0 -l0000000000016D68: - a4 = 0x11000<64> - a4 = a4 + 1848 - goto l0000000000016BE0 - // succ: l0000000000016BE0 + a4_101 = 0x11710<64> +l0000000000016CC4: + a4_101 = 0x11650<64> +l0000000000016BCC: + a4_101 = 0x11748<64> +l0000000000016BE0: + return a4_101 fn0000000000016B68_exit: -// fn0000000000016D74 -// Return size: 0 -define fn0000000000016D74 +word64 fn0000000000016D74(word64 ra, word64 gp, word64 a0, word64 a1, word64 a2, word64 a3, ptr64 & a4Out) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// Called from: +// fn0000000000015180 +// MayUse: a0:[0..63] a1:[0..63] a2:[0..63] a3:[0..63] gp:[0..63] ra:[0..63] +// LiveOut: a0:[0..63]-fn0000000000015180 a4:[0..63]-fn0000000000015180 +// Trashed: a0 a1 a2 a4 a5 +// Preserved: a3 a6 a7 fa3 fa4 fa5 gp ra s0 s1 s2 s3 s4 s5 s6 s7 s8 sp t1 t3 t4 t5 fn0000000000016D74_entry: - sp = fp - // succ: l0000000000016D74 l0000000000016D74: - sp = sp + -448 - Mem0[sp + 376:word64] = s7 - a5 = Mem0[gp + -1936:word64] - Mem0[sp + 384:word64] = s6 - s6 = a2 - Mem0[sp + 424:word64] = s1 - Mem0[sp + 392:word64] = s5 - s1 = a0 - a2 = 200 - s5 = a1 - a0 = s6 - a1 = 0 - Mem0[sp + 368:word64] = s8 - Mem0[sp + 440:word64] = ra - Mem0[sp + 432:word64] = s0 - Mem0[sp + 416:word64] = s2 - Mem0[sp + 408:word64] = s3 - Mem0[sp + 400:word64] = s4 - s8 = a3 - Mem0[sp + 360:word64] = a5 - a0 = memset(a0, SLICE(a1, int32, 0), SLICE(a2, size_t, 0)) - a2 = sp + 8 - a1 = s1 - a0 = 2 - a0 = SEQ(0<32>, inet_pton(SLICE(a0, int32, 0), a1, a2)) - branch 0<64> >= a0 l0000000000016E60 - // succ: l0000000000016DDC l0000000000016E60 -l0000000000016DDC: - branch s5 < 0<64> l0000000000016E88 - // succ: l0000000000016DE0 l0000000000016E88 -l0000000000016DE0: - Mem0[sp + 48:word64] = s1 - a0 = s1 - s0 = 3 - s2 = 46 - // succ: l0000000000016DF0 -l0000000000016DF0: - a1 = s2 - a0 = strchr(a0, SLICE(a1, char, 0)) - Mem0[sp + 48:word64] = a0 - branch a0 == 0<64> l0000000000017194 - // succ: l0000000000016E00 l0000000000017194 -l0000000000016E00: - a0 = a0 + 1 - Mem0[sp + 48:word64] = a0 - v23 = SLICE(s0, word32, 0) - s0 = CONVERT(v23 - 1, word32, int64) - branch s0 != 0<64> l0000000000016DF0 - // succ: l0000000000016E10 l0000000000016DF0 -l0000000000016E10: - a5 = 32 - branch a5 >= s5 l0000000000016EBC - // succ: l0000000000016E18 l0000000000016EBC -l0000000000016E18: - a5 = CONVERT(Mem0[gp + -2028:int32], int32, int64) - branch a5 == 0<64> l0000000000017054 - // succ: l0000000000016E20 l0000000000017054 -l0000000000016E20: - a0 = -1 - // succ: l0000000000016E24 -l0000000000016E24: - a4 = Mem0[sp + 360:word64] - a5 = Mem0[gp + -1936:word64] - branch a4 != a5 l00000000000172D8 - // succ: l0000000000016E30 l00000000000172D8 -l0000000000016E30: - ra = Mem0[sp + 440:word64] - s0 = Mem0[sp + 432:word64] - s1 = Mem0[sp + 424:word64] - s2 = Mem0[sp + 416:word64] - s3 = Mem0[sp + 408:word64] - s4 = Mem0[sp + 400:word64] - s5 = Mem0[sp + 392:word64] - s6 = Mem0[sp + 384:word64] - s7 = Mem0[sp + 376:word64] - s8 = Mem0[sp + 368:word64] - sp = sp + 448 - return - // succ: fn0000000000016D74_exit + a5_7 = Mem5[gp + -1936:word64] + memset(a2, 0, SLICE(200, size_t, 0)) + s6_11 = a2 + s1_17 = a0 + s5_119 = a1 + branch CONVERT(inet_pton(2, a0, &qwLoc01B8), uint32, uint64) <= 0<64> l0000000000016E60 l0000000000016E60: - a5 = CONVERT(Mem0[gp + -2028:int32], int32, int64) - branch a5 != 0<64> l0000000000016E20 - // succ: l0000000000016E68 l0000000000016E20 + branch CONVERT(Mem37[gp + -2028:int32], int32, int64) != 0<64> l0000000000016E20 l0000000000016E68: - a0 = Mem0[gp + -1920:word64] - a2 = 0x11000<64> - a3 = s1 - a2 = a2 + 1928 - a1 = 1 - a0 = SEQ(0<32>, __fprintf_chk(a0, SLICE(a1, int32, 0), a2, a3)) - a0 = -1 - goto l0000000000016E24 - // succ: l0000000000016E24 + __fprintf_chk(Mem37[gp + -1920:word64], 1, 0x11788<64>, a0) + a0_449 = -1 +l0000000000016DDC: + branch a1 < 0<64> l0000000000016E88 l0000000000016E88: - a5 = s8 << 0x2D - s5 = 32 - branch a5 >= 0<64> l0000000000016EBC - // succ: l0000000000016E94 l0000000000016EBC + s5_119 = 32 + branch a3 << 0x2D >= 0<64> l0000000000016EBC l0000000000016E94: - a0 = CONVERT(Mem0[sp + 8:int32], int32, int64) - s5 = 8 - call fn00000000000182B4 (retsize: 0;) - a5 = CONVERT(SLICE(a0, word32, 0) >>u 24, word32, int64) - branch a0 >= 0<64> l0000000000016EBC - // succ: l0000000000016EA8 l0000000000016EBC + a0_55 = fn00000000000182B4(CONVERT(Mem37[&qwLoc01B8:int32], int32, int64), out a3_808, out a4_809) + s5_119 = 8 + a5_59 = CONVERT(SLICE(a0_55, word32, 0) >>u 24, word32, int64) + branch a0_55 >= 0<64> l0000000000016EBC l0000000000016EA8: - v35 = SLICE(a5, word32, 0) - a5 = CONVERT(v35 - 128, word32, int64) - a4 = 63 - s5 = 24 - branch a4 + branch CONVERT(SLICE(a5_59, word32, 0) - 128, word32, int64) >u 63 l0000000000016EBC l0000000000016EB8: - s5 = 16 - // succ: l0000000000016EBC + s5_119 = 16 +l0000000000016DE0: + Mem65[&ptrLoc0190:word64] = a0 + a0_66 = a0 + s0_100 = 3 +l0000000000016DF0: + a0_72 = strchr(a0_66, '.') + Mem74[&ptrLoc0190:word64] = a0_72 + branch a0_72 == 0<64> l0000000000017194 +l0000000000017194: +l00000000000171A0: + branch CONVERT(__asprintf_chk(&ptrLoc0190, 1, 0x117A8<64>, s1_17), uint32, uint64) == -1 l00000000000172BC +l00000000000172BC: + a0_141 = Mem74[gp + -1920:word64] + a3_142 = 613 +l00000000000171B8: + s0_100 = CONVERT(SLICE(s0_100, word32, 0) - 1, word32, int64) + s1_17 = Mem74[&ptrLoc0190:word64] + branch s0_100 != 0<64> l00000000000171A0 +l00000000000171C4: +l0000000000016E00: + Mem97[&ptrLoc0190:word64] = a0_72 + 1 + a0_66 = a0_72 + 1 + s0_100 = CONVERT(SLICE(s0_100, word32, 0) - 1, word32, int64) + branch s0_100 != 0<64> l0000000000016DF0 +l0000000000016E10: + branch a1 <= 32 l0000000000016EBC l0000000000016EBC: - a3 = 47 - a2 = sp + 56 - a1 = sp + 8 - a0 = 2 - a0 = inet_ntop(SLICE(a0, int32, 0), a1, a2, SLICE(a3, socklen_t, 0)) - branch a0 == 0<64> l0000000000017074 - // succ: l0000000000016ED4 l0000000000017074 + branch inet_ntop(2, &qwLoc01B8, &bLoc0188, 47) == 0<64> l0000000000017074 l0000000000016ED4: - a0 = sp + 56 - a0 = __strdup(a0) - Mem0[s6:word64] = a0 - a0 = s5 - call fn0000000000016830 (retsize: 0;) - Mem0[sp + 16:word32] = SLICE(a0, word32, 0) - a3 = 16 - a2 = sp + 56 - a1 = sp + 16 - a0 = 2 - Mem0[sp + 56:word64] = 0<64> - Mem0[sp + 64:word64] = 0<64> - Mem0[sp + 72:word64] = 0<64> - Mem0[sp + 80:word64] = 0<64> - Mem0[sp + 88:word64] = 0<64> - Mem0[sp + 96:word32] = SLICE(0<64>, word32, 0) - Mem0[sp + 100:word16] = SLICE(0<64>, word16, 0) - Mem0[sp + 102:byte] = SLICE(0<64>, byte, 0) - a0 = inet_ntop(SLICE(a0, int32, 0), a1, a2, SLICE(a3, socklen_t, 0)) - branch a0 == 0<64> l0000000000017300 - // succ: l0000000000016F24 l0000000000017300 + Mem118[a2:word64] = __strdup(&bLoc0188) + Mem127[&qwLoc01B0:word32] = SLICE(fn0000000000016830(gp, s5_119), word32, 0) + Mem132[&bLoc0188:word64] = 0<64> + branch inet_ntop(2, &qwLoc01B0, &bLoc0188, 16) == 0<64> l0000000000017300 +l0000000000017300: + a0_141 = Mem139[gp + -1920:word64] + a3_142 = 644 l0000000000016F24: - a0 = sp + 56 - a0 = __strdup(a0) - Mem0[s6 + 48:word64] = a0 - s0 = CONVERT(Mem0[sp + 8:int32], int32, int64) - Mem0[s6 + 160:word32] = SLICE(s5, word32, 0) - a0 = s5 - call fn0000000000016830 (retsize: 0;) - a5 = a0 ^ -1 - a5 = a5 | s0 - a3 = 16 - a2 = sp + 56 - a1 = sp + 32 - a0 = 2 - Mem0[sp + 32:word32] = SLICE(a5, word32, 0) - Mem0[sp + 56:word64] = 0<64> - Mem0[sp + 64:word64] = 0<64> - Mem0[sp + 72:word64] = 0<64> - Mem0[sp + 80:word64] = 0<64> - Mem0[sp + 88:word64] = 0<64> - Mem0[sp + 96:word32] = SLICE(0<64>, word32, 0) - Mem0[sp + 100:word16] = SLICE(0<64>, word16, 0) - Mem0[sp + 102:byte] = SLICE(0<64>, byte, 0) - a0 = inet_ntop(SLICE(a0, int32, 0), a1, a2, SLICE(a3, socklen_t, 0)) - branch a0 == 0<64> l00000000000172F4 - // succ: l0000000000016F84 l00000000000172F4 + Mem145[a2 + 48:word64] = __strdup(&bLoc0188) + s0_146 = CONVERT(Mem145[&qwLoc01B8:int32], int32, int64) + Mem147[a2 + 160:word32] = SLICE(s5_119, word32, 0) + Mem158[&qwLoc01A0:word32] = SLICE(~fn0000000000016830(gp, s5_119) | s0_146, word32, 0) + Mem159[&bLoc0188:word64] = 0<64> + branch inet_ntop(2, &qwLoc01A0, &bLoc0188, 16) == 0<64> l00000000000172F4 +l00000000000172F4: + a0_141 = Mem166[gp + -1920:word64] + a3_142 = 655 l0000000000016F84: - a0 = sp + 56 - a0 = __strdup(a0) - Mem0[s6 + 40:word64] = a0 - s0 = CONVERT(Mem0[sp + 8:int32], int32, int64) - a0 = s5 - call fn0000000000016830 (retsize: 0;) - a3 = CONVERT(Mem0[sp + 32:int32], int32, int64) - s0 = a0 & s0 - a2 = s0 - a1 = s5 - a0 = s0 - Mem0[sp + 24:word32] = SLICE(s0, word32, 0) - call fn0000000000017F04 (retsize: 0;) - Mem0[s6 + 24:word64] = a0 - a3 = 16 - a2 = sp + 56 - a1 = sp + 24 - a0 = 2 - Mem0[sp + 56:word64] = 0<64> - Mem0[sp + 64:word64] = 0<64> - Mem0[sp + 72:word64] = 0<64> - Mem0[sp + 80:word64] = 0<64> - Mem0[sp + 88:word64] = 0<64> - Mem0[sp + 96:word32] = SLICE(0<64>, word32, 0) - Mem0[sp + 100:word16] = SLICE(0<64>, word16, 0) - Mem0[sp + 102:byte] = SLICE(0<64>, byte, 0) - a0 = inet_ntop(SLICE(a0, int32, 0), a1, a2, SLICE(a3, socklen_t, 0)) - branch a0 == 0<64> l00000000000172DC - // succ: l0000000000016FF4 l00000000000172DC + Mem172[a2 + 40:word64] = __strdup(&bLoc0188) + s0_173 = CONVERT(Mem172[&qwLoc01B8:int32], int32, int64) + a0_175 = fn0000000000016830(gp, s5_119) + a3_178 = CONVERT(Mem172[&qwLoc01A0:int32], int32, int64) + s0_179 = a0_175 & s0_173 + Mem183[&qwLoc01A8:word32] = SLICE(s0_179, word32, 0) + Mem193[a2 + 24:word64] = fn0000000000017F04(gp, s0_179, s5_119, s0_179, a3_178) + Mem198[&bLoc0188:word64] = 0<64> + branch inet_ntop(2, &qwLoc01A8, &bLoc0188, 16) == 0<64> l00000000000172DC +l00000000000172DC: + a0_141 = Mem205[gp + -1920:word64] + a3_142 = 667 l0000000000016FF4: - a0 = sp + 56 - a0 = __strdup(a0) - s0 = CONVERT(Mem0[sp + 24:int32], int32, int64) - Mem0[s6 + 32:word64] = a0 - s3 = a0 - a0 = s0 - call fn0000000000016B68 (retsize: 0;) - Mem0[s6 + 184:word64] = a0 - a0 = s0 - call fn00000000000182B4 (retsize: 0;) - a5 = CONVERT(SLICE(a0, word32, 0) >>u 24, word32, int64) - branch a0 >= 0<64> l0000000000017098 - // succ: l0000000000017024 l0000000000017098 + a0_210 = __strdup(&bLoc0188) + s0_211 = CONVERT(Mem205[&qwLoc01A8:int32], int32, int64) + Mem212[a2 + 32:word64] = a0_210 + Mem222[a2 + 184:word64] = fn0000000000016B68(s0_211) + a0_224 = fn00000000000182B4(s0_211, out a3_802, out a4_803) + a5_228 = CONVERT(SLICE(a0_224, word32, 0) >>u 24, word32, int64) + branch a0_224 >= 0<64> l0000000000017098 +l0000000000017098: + a5_230 = 0x11758<64> l0000000000017024: - v26 = SLICE(a5, word32, 0) - a4 = CONVERT(v26 - 128, word32, int64) - a3 = 63 - branch a3 >=u a4 l000000000001727C - // succ: l0000000000017030 l000000000001727C + branch CONVERT(SLICE(a5_228, word32, 0) - 128, word32, int64) <=u 63 l000000000001727C +l000000000001727C: + a5_230 = 0x11760<64> l0000000000017030: - v27 = SLICE(a5, word32, 0) - a4 = CONVERT(v27 - 192, word32, int64) - a3 = 31 - branch a3 >=u a4 l00000000000172A4 - // succ: l000000000001703C l00000000000172A4 + branch CONVERT(SLICE(a5_228, word32, 0) - 192, word32, int64) <=u 31 l00000000000172A4 +l00000000000172A4: + a5_230 = 0x11768<64> l000000000001703C: - v28 = SLICE(a5, word32, 0) - a5 = CONVERT(v28 - 224, word32, int64) - a4 = 14 - branch a4 , word32, int64) >u 14 l00000000000172B0 +l00000000000172B0: + a5_230 = 0x11778<64> l0000000000017048: - a5 = 0x11000<64> - a5 = a5 + 1904 - goto l00000000000170A0 - // succ: l00000000000170A0 -l0000000000017054: - a0 = Mem0[gp + -1920:word64] - a2 = 0x11000<64> - a3 = s5 - a2 = a2 + 2008 - a1 = 1 - a0 = SEQ(0<32>, __fprintf_chk(a0, SLICE(a1, int32, 0), a2, SLICE(a3, int32, 0))) - a0 = -1 - goto l0000000000016E24 - // succ: l0000000000016E24 -l0000000000017074: - a5 = CONVERT(Mem0[gp + -2028:int32], int32, int64) - branch a5 != 0<64> l0000000000016E20 - // succ: l000000000001707C l0000000000016E20 -l000000000001707C: - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 43 - a1 = 1 - a0 = a0 + 2040 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - goto l0000000000016E20 - // succ: l0000000000016E20 -l0000000000017098: - a5 = 0x11000<64> - a5 = a5 + 1880 - // succ: l00000000000170A0 + a5_230 = 0x11770<64> l00000000000170A0: - Mem0[s6 + 192:word64] = a5 - s2 = 32 - branch s5 == s2 l0000000000017158 - // succ: l00000000000170AC l0000000000017158 + Mem250[a2 + 192:word64] = a5_230 + branch s5_119 == 32 l0000000000017158 +l0000000000017158: + Mem255[a2 + 168:word64] = a0_210 + Mem256[a2 + 176:word64] = a0_210 + a5_258 = 0x11780<64> l00000000000170AC: - Mem0[sp + 40:word32] = SLICE(s0, word32, 0) - a5 = 31 - branch s5 == a5 l0000000000017210 - // succ: l00000000000170B8 l0000000000017210 + Mem261[&qwLoc0198:word32] = SLICE(s0_211, word32, 0) + branch s5_119 == 31 l0000000000017210 +l0000000000017210: + branch inet_ntop(2, &qwLoc0198, &bLoc0188, 16) == 0<64> l00000000000172E8 +l0000000000017228: + a0_269 = __strdup(&bLoc0188) + a5_270 = CONVERT(Mem261[&qwLoc01B0:int32], int32, int64) + a4_271 = CONVERT(Mem261[&qwLoc01A8:int32], int32, int64) + Mem272[a2 + 168:word64] = a0_269 + Mem279[&ptrLoc0190:word32] = SLICE(~a5_270 | a4_271, word32, 0) + branch inet_ntop(2, &ptrLoc0190, &bLoc0188, 47) == 0<64> l0000000000017074 +l0000000000017260: + Mem284[a2 + 176:word64] = __strdup(&bLoc0188) + a5_258 = 0x12660<64> +l000000000001716C: + Mem291[a2 + 96:byte] = Mem288[a5_258:byte] + Mem293[a2 + 97:byte] = Mem291[a5_258 + 1:byte] l00000000000170B8: - a5 = 0x1000000<64> - s0 = s0 | a5 - a3 = 16 - a2 = sp + 56 - a1 = sp + 40 - a0 = 2 - Mem0[sp + 40:word32] = SLICE(s0, word32, 0) - a0 = inet_ntop(SLICE(a0, int32, 0), a1, a2, SLICE(a3, socklen_t, 0)) - branch a0 == 0<64> l00000000000172E8 - // succ: l00000000000170DC l00000000000172E8 + Mem300[&qwLoc0198:word32] = SLICE(s0_211, word32, 0) | 0x1000000<32> + branch inet_ntop(2, &qwLoc0198, &bLoc0188, 16) == 0<64> l00000000000172E8 +l00000000000172E8: + a0_141 = Mem304[gp + -1920:word64] + a3_142 = 684 +l00000000000172C4: + __fprintf_chk(a0_141, 1, 0x117B0<64>, SLICE(a3_142, int32, 0)) + abort() l00000000000170DC: - a0 = sp + 56 - a0 = __strdup(a0) - a5 = CONVERT(Mem0[sp + 16:int32], int32, int64) - Mem0[s6 + 168:word64] = a0 - a0 = CONVERT(Mem0[sp + 24:int32], int32, int64) - a5 = a5 ^ -1 - a0 = a5 | a0 - call fn00000000000182B4 (retsize: 0;) - v30 = SLICE(a0, word32, 0) - a0 = CONVERT(v30 - 1, word32, int64) - call fn00000000000182B4 (retsize: 0;) - Mem0[sp + 48:word32] = SLICE(a0, word32, 0) - a3 = 47 - a2 = sp + 56 - a1 = sp + 48 - a0 = 2 - a0 = inet_ntop(SLICE(a0, int32, 0), a1, a2, SLICE(a3, socklen_t, 0)) - branch a0 == 0<64> l0000000000017074 - // succ: l0000000000017120 l0000000000017074 + a0_314 = __strdup(&bLoc0188) + a5_315 = CONVERT(Mem300[&qwLoc01B0:int32], int32, int64) + Mem316[a2 + 168:word64] = a0_314 + Mem330[&ptrLoc0190:word32] = SLICE(fn00000000000182B4(CONVERT(SLICE(fn00000000000182B4(~a5_315 | CONVERT(Mem316[&qwLoc01A8:int32], int32, int64), out a3_804, out a4_805), word32, 0) - 1, word32, int64), out a3_806, out a4_807), word32, 0) + branch inet_ntop(2, &ptrLoc0190, &bLoc0188, 47) == 0<64> l0000000000017074 +l0000000000017074: + branch CONVERT(Mem337[gp + -2028:int32], int32, int64) != 0<64> l0000000000016E20 +l000000000001707C: + fwrite(0x117F8<64>, SLICE(1, size_t, 0), SLICE(43, size_t, 0), Mem337[gp + -1920:word64]) l0000000000017120: - a0 = sp + 56 - a0 = __strdup(a0) - a2 = 1 - v31 = SLICE(s2, word32, 0) - v32 = SLICE(s5, word32, 0) - a5 = CONVERT(v31 - v32, word32, int64) - a5 = CONVERT(SLICE(a2, word32, 0) << a5, word32, int64) - a3 = 64 - a4 = 0x12000<64> - Mem0[s6 + 176:word64] = a0 - v33 = SLICE(a5, word32, 0) - a5 = CONVERT(v33 - 2, word32, int64) - a4 = a4 + -2008 - a1 = a3 - a0 = s6 + 96 - a0 = SEQ(0<32>, __snprintf_chk(a0, SLICE(a1, size_t, 0), SLICE(a2, int32, 0), SLICE(a3, size_t, 0), a4, SLICE(a5, uint32, 0))) - goto l000000000001717C - // succ: l000000000001717C -l0000000000017158: - a5 = 0x11000<64> - Mem0[s6 + 168:word64] = s3 - Mem0[s6 + 176:word64] = s3 - a4 = s6 + 96 - a5 = a5 + 1920 - // succ: l000000000001716C -l000000000001716C: - a3 = CONVERT(Mem0[a5:byte], byte, word64) - Mem0[a4:byte] = SLICE(a3, byte, 0) - a5 = CONVERT(Mem0[a5 + 1:byte], byte, word64) - Mem0[a4 + 1:byte] = SLICE(a5, byte, 0) - // succ: l000000000001717C + Mem356[a2 + 176:word64] = __strdup(&bLoc0188) + __snprintf_chk(a2 + 96, SLICE(64, size_t, 0), 1, SLICE(64, size_t, 0), 0x11828<64>, (1<32> << CONVERT(0x20<32> - SLICE(s5_119, word32, 0), word32, int64)) - 2) l000000000001717C: - a5 = s8 << 0x31 - branch a5 < 0<64> l0000000000017288 - // succ: l0000000000017184 l0000000000017288 + branch a3 << 0x31 < 0<64> l0000000000017288 +l0000000000017288: + gp = fn0000000000017B40(ra, gp, CONVERT(Mem373[&qwLoc01B8:int32], int32, int64), a2 + 64, a2 + 72, a2 + 80, a2 + 88, s5_119, a2, out s1_17, out s6_11) l0000000000017184: - s8 = s8 & 1 - branch s8 != 0<64> l00000000000171C8 - // succ: l000000000001718C l00000000000171C8 -l000000000001718C: - a0 = 0 - goto l0000000000016E24 - // succ: l0000000000016E24 -l0000000000017194: - s4 = 0x11000<64> - s3 = 1 - s2 = -1 - // succ: l00000000000171A0 -l00000000000171A0: - a3 = s1 - a2 = s4 + 1960 - a1 = s3 - a0 = sp + 48 - a0 = SEQ(0<32>, __asprintf_chk(a0, SLICE(a1, int32, 0), a2, a3)) - branch a0 == s2 l00000000000172BC - // succ: l00000000000171B8 l00000000000172BC -l00000000000171B8: - v29 = SLICE(s0, word32, 0) - s0 = CONVERT(v29 - 1, word32, int64) - s1 = Mem0[sp + 48:word64] - branch s0 != 0<64> l00000000000171A0 - // succ: l00000000000171C4 l00000000000171A0 -l00000000000171C4: - goto l0000000000016E10 - // succ: l0000000000016E10 + branch (a3 & 1) != 0<64> l00000000000171C8 l00000000000171C8: - a1 = sp + 8 - a0 = 2 - call fn00000000000168E4 (retsize: 0;) - Mem0[s6 + 56:word64] = a0 - branch a0 != 0<64> l000000000001718C - // succ: l00000000000171DC l000000000001718C + a0_419 = fn00000000000168E4(gp, 2, &qwLoc01B8) + Mem432[s6_11 + 56:word64] = a0_419 + branch a0_419 != 0<64> l000000000001718C l00000000000171DC: - a5 = CONVERT(Mem0[gp + -2028:int32], int32, int64) - branch a5 != 0<64> l0000000000016E20 - // succ: l00000000000171E4 l0000000000016E20 + branch CONVERT(Mem432[gp + -2028:int32], int32, int64) != 0<64> l0000000000016E20 l00000000000171E4: - a3 = 0x12000<64> - a4 = s1 - a3 = a3 + -2000 - a2 = 250 - a1 = 1 - a0 = sp + 104 - a0 = SEQ(0<32>, __sprintf_chk(a0, SLICE(a1, int32, 0), SLICE(a2, size_t, 0), a3, a4)) - a0 = sp + 104 - herror(a0) - a0 = -1 - goto l0000000000016E24 - // succ: l0000000000016E24 -l0000000000017210: - a3 = 16 - a2 = sp + 56 - a1 = sp + 40 - a0 = 2 - a0 = inet_ntop(SLICE(a0, int32, 0), a1, a2, SLICE(a3, socklen_t, 0)) - branch a0 == 0<64> l00000000000172E8 - // succ: l0000000000017228 l00000000000172E8 -l0000000000017228: - a0 = sp + 56 - a0 = __strdup(a0) - a5 = CONVERT(Mem0[sp + 16:int32], int32, int64) - a4 = CONVERT(Mem0[sp + 24:int32], int32, int64) - Mem0[s6 + 168:word64] = a0 - a5 = a5 ^ -1 - a5 = a5 | a4 - a3 = 47 - a2 = sp + 56 - a1 = sp + 48 - a0 = 2 - Mem0[sp + 48:word32] = SLICE(a5, word32, 0) - a0 = inet_ntop(SLICE(a0, int32, 0), a1, a2, SLICE(a3, socklen_t, 0)) - branch a0 == 0<64> l0000000000017074 - // succ: l0000000000017260 l0000000000017074 -l0000000000017260: - a0 = sp + 56 - a0 = __strdup(a0) - a5 = 0x12000<64> - Mem0[s6 + 176:word64] = a0 - a4 = s6 + 96 - a5 = a5 + 1632 - goto l000000000001716C - // succ: l000000000001716C -l000000000001727C: - a5 = 0x11000<64> - a5 = a5 + 1888 - goto l00000000000170A0 - // succ: l00000000000170A0 -l0000000000017288: - a0 = CONVERT(Mem0[sp + 8:int32], int32, int64) - a4 = s6 + 88 - a3 = s6 + 80 - a2 = s6 + 72 - a1 = s6 + 64 - call fn0000000000017B40 (retsize: 0;) - goto l0000000000017184 - // succ: l0000000000017184 -l00000000000172A4: - a5 = 0x11000<64> - a5 = a5 + 1896 - goto l00000000000170A0 - // succ: l00000000000170A0 -l00000000000172B0: - a5 = 0x11000<64> - a5 = a5 + 1912 - goto l00000000000170A0 - // succ: l00000000000170A0 -l00000000000172BC: - a0 = Mem0[gp + -1920:word64] - a3 = 613 - // succ: l00000000000172C4 -l00000000000172C4: - a2 = 0x11000<64> - a2 = a2 + 1968 - a1 = 1 - a0 = SEQ(0<32>, __fprintf_chk(a0, SLICE(a1, int32, 0), a2, SLICE(a3, int32, 0))) - abort() + __sprintf_chk(&bLoc0158, 1, SLICE(250, size_t, 0), 0x11830<64>, s1_17) + herror(&bLoc0158) + a0_449 = -1 +l000000000001718C: + a0_449 = 0 +l0000000000016E18: + branch CONVERT(Mem339[gp + -2028:int32], int32, int64) == 0<64> l0000000000017054 +l0000000000017054: + __fprintf_chk(Mem339[gp + -1920:word64], 1, 0x117D8<64>, SLICE(a1, int32, 0)) + a0_449 = -1 +l0000000000016E20: + a0_449 = -1 +l0000000000016E24: + branch a5_7 != Mem464[gp + -1936:word64] l00000000000172D8 l00000000000172D8: __stack_chk_fail() -l00000000000172DC: - a0 = Mem0[gp + -1920:word64] - a3 = 667 - goto l00000000000172C4 - // succ: l00000000000172C4 -l00000000000172E8: - a0 = Mem0[gp + -1920:word64] - a3 = 684 - goto l00000000000172C4 - // succ: l00000000000172C4 -l00000000000172F4: - a0 = Mem0[gp + -1920:word64] - a3 = 655 - goto l00000000000172C4 - // succ: l00000000000172C4 -l0000000000017300: - a0 = Mem0[gp + -1920:word64] - a3 = 644 - goto l00000000000172C4 - // succ: l00000000000172C4 +l0000000000016E30: + a4Out = a5_7 + return a0_449 fn0000000000016D74_exit: -// fn000000000001730C -// Return size: 0 -define fn000000000001730C +word64 fn000000000001730C(word64 gp, word64 a0, word64 a1) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// Called from: +// fn00000000000175BC +// MayUse: a0:[0..63] a1:[0..63] gp:[0..63] +// LiveOut: a0:[0..63]-fn00000000000175BC +// Trashed: a0 a4 a5 +// Preserved: a1 a2 a3 a6 ra s0 s1 sp fn000000000001730C_entry: - sp = fp - // succ: l000000000001730C l000000000001730C: - sp = sp + -192 - Mem0[sp + 176:word64] = s0 - a4 = Mem0[gp + -1936:word64] - Mem0[sp + 184:word64] = ra - Mem0[sp + 168:word64] = s1 - a5 = 128 - Mem0[sp + 152:word64] = a4 - branch a5 :word64] + branch a0 >u 128 l00000000000173BC l000000000001732C: - a4 = 8 - Mem0[sp + 8:word64] = 0<64> - Mem0[sp + 16:word64] = 0<64> - s1 = a1 - a5 = sp + 8 - v12 = SLICE(a4, word32, 0) - v13 = SLICE(a0, word32, 0) - a4 = CONVERT(v12 - v13, word32, int64) - a3 = 7 - a2 = -1 - a1 = 255 + Mem16[&qwLocB8:word64] = 0<64> + a5_20 = &qwLocB8 + a4_23 = CONVERT(8<32> - SLICE(a0, word32, 0), word32, int64) branch a0 == 0<64> l000000000001736C - // succ: l0000000000017354 l000000000001736C l0000000000017354: - branch a3 >= a0 l00000000000173C4 - // succ: l0000000000017358 l00000000000173C4 + branch a0 <= 7 l00000000000173C4 +l00000000000173C4: + Mem33[a5_20:byte] = 0xFF<8> << SLICE(a4_23, byte, 0) l0000000000017358: - Mem0[a5:byte] = SLICE(a2, byte, 0) - // succ: l000000000001735C + Mem35[a5_20:byte] = 0xFF<8> l000000000001735C: - v16 = SLICE(a0, word32, 0) - a0 = CONVERT(v16 - 8, word32, int64) - a5 = a5 + 1 - v17 = SLICE(a4, word32, 0) - a4 = CONVERT(v17 + 8, word32, int64) - branch 0<64> < a0 l0000000000017354 - // succ: l000000000001736C l0000000000017354 + a0 = CONVERT(SLICE(a0, word32, 0) - 8, word32, int64) + a5_20 = a5_20 + 1 + a4_23 = CONVERT(SLICE(a4_23, word32, 0) + 8, word32, int64) + branch a0 > 0<64> l0000000000017354 l000000000001736C: - a3 = 128 - a2 = sp + 24 - a1 = sp + 8 - a0 = 10 - a0 = inet_ntop(SLICE(a0, int32, 0), a1, a2, SLICE(a3, socklen_t, 0)) - branch a0 == 0<64> l00000000000173BC - // succ: l0000000000017384 l00000000000173BC + branch inet_ntop(10, &qwLocB8, &bLocA8, 128) == 0<64> l00000000000173BC +l00000000000173BC: + a0_109 = 0 l0000000000017384: - a2 = 16 - a1 = sp + 8 - a0 = s1 - a0 = memcpy(a0, a1, SLICE(a2, size_t, 0)) - a0 = sp + 24 - a0 = __strdup(a0) - // succ: l000000000001739C + memcpy(a1, &qwLocB8, SLICE(16, size_t, 0)) + a0_109 = __strdup(&bLocA8) l000000000001739C: - a4 = Mem0[sp + 152:word64] - a5 = Mem0[gp + -1936:word64] - branch a4 != a5 l00000000000173D0 - // succ: l00000000000173A8 l00000000000173D0 -l00000000000173A8: - ra = Mem0[sp + 184:word64] - s0 = Mem0[sp + 176:word64] - s1 = Mem0[sp + 168:word64] - sp = sp + 192 - return - // succ: fn000000000001730C_exit -l00000000000173BC: - a0 = 0 - goto l000000000001739C - // succ: l000000000001739C -l00000000000173C4: - a6 = CONVERT(SLICE(a1, word32, 0) << a4, word32, int64) - Mem0[a5:byte] = SLICE(a6, byte, 0) - goto l000000000001735C - // succ: l000000000001735C + branch a4_7 != Mem64[gp + -1936:word64] l00000000000173D0 l00000000000173D0: __stack_chk_fail() +l00000000000173A8: + return a0_109 fn000000000001730C_exit: -// fn00000000000173D4 -// Return size: 0 -define fn00000000000173D4 +word64 fn00000000000173D4(word64 a0, word64 a1) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// Called from: +// fn00000000000175BC +// MayUse: a0:[0..63] a1:[0..63] +// LiveOut: a0:[0..63]-fn00000000000175BC +// Trashed: a0 a1 a2 a3 a4 a5 +// Preserved: ra s0 s1 s2 s3 sp fn00000000000173D4_entry: - sp = fp - // succ: l00000000000173D4 l00000000000173D4: - sp = sp + -48 - Mem0[sp + 32:word64] = s0 - Mem0[sp + 40:word64] = ra - Mem0[sp + 24:word64] = s1 - Mem0[sp + 16:word64] = s2 - Mem0[sp + 8:word64] = s3 - a5 = 128 - s0 = a0 - s2 = CONVERT(Mem0[a0:byte], byte, word64) - s3 = CONVERT(Mem0[a0 + 1:byte], byte, word64) - branch a1 == a5 l00000000000174DC - // succ: l0000000000017400 l00000000000174DC + s2_17 = CONVERT(Mem13[a0:byte], byte, word64) + s3_18 = CONVERT(Mem13[a0 + 1:byte], byte, word64) + branch a1 == 128 l00000000000174DC +l00000000000174DC: + branch CONVERT(memcmp(a0, 0x10880<64>, SLICE(16, size_t, 0)), uint32, uint64) == 0<64> l0000000000017538 +l0000000000017538: + return 0x11858<64> +l00000000000174F4: + branch CONVERT(memcmp(a0, 0x10898<64>, SLICE(16, size_t, 0)), uint32, uint64) != 0<64> l000000000001747C +l0000000000017508: + a0_102 = 0x11870<64> l0000000000017400: - a5 = 95 - branch a5 < a1 l0000000000017474 - // succ: l0000000000017408 l0000000000017474 -l0000000000017408: - a5 = s2 << 8 - a5 = a5 | s3 - a4 = 0xFFFFE000<64> - a4 = a4 & a5 - a3 = 0x2000<64> - branch a4 == a3 l0000000000017580 - // succ: l0000000000017420 l0000000000017580 -l0000000000017420: - a4 = s2 & 254 - a2 = 252 - branch a4 == a2 l000000000001758C - // succ: l000000000001742C l000000000001758C -l000000000001742C: - a4 = 0x10000<64> - a2 = a5 & -64 - v15 = SLICE(a4, word32, 0) - a4 = CONVERT(v15 - 384, word32, int64) - branch a2 == a4 l0000000000017598 - // succ: l000000000001743C l0000000000017598 -l000000000001743C: - a4 = 255 - branch s2 == a4 l00000000000175A4 - // succ: l0000000000017444 l00000000000175A4 -l0000000000017444: - a0 = 0x11000<64> - a5 = a5 & -2 - v16 = SLICE(a3, word32, 0) - a3 = CONVERT(v16 + 2, word32, int64) - a0 = a0 + 1808 - branch a5 == a3 l00000000000175B0 - // succ: l0000000000017458 l00000000000175B0 -l0000000000017458: - ra = Mem0[sp + 40:word64] - s0 = Mem0[sp + 32:word64] - s1 = Mem0[sp + 24:word64] - s2 = Mem0[sp + 16:word64] - s3 = Mem0[sp + 8:word64] - sp = sp + 48 - return - // succ: fn00000000000173D4_exit + branch a1 > 95 l0000000000017474 l0000000000017474: - s1 = 0x10000<64> - s1 = s1 + 1152 - // succ: l000000000001747C l000000000001747C: - a2 = 12 - a1 = s1 + 1072 - a0 = s0 - a0 = SEQ(0<32>, memcmp(a0, a1, SLICE(a2, size_t, 0))) - branch a0 == 0<64> l000000000001755C - // succ: l0000000000017490 l000000000001755C + branch CONVERT(memcmp(a0, 0x108B0<64>, SLICE(12, size_t, 0)), uint32, uint64) == 0<64> l000000000001755C +l000000000001755C: + return 0x11888<64> l0000000000017490: - a2 = 12 - a1 = s1 + 1088 - a0 = s0 - a0 = SEQ(0<32>, memcmp(a0, a1, SLICE(a2, size_t, 0))) - branch a0 == 0<64> l0000000000017514 - // succ: l00000000000174A4 l0000000000017514 + branch CONVERT(memcmp(a0, 0x108C0<64>, SLICE(12, size_t, 0)), uint32, uint64) == 0<64> l0000000000017514 +l0000000000017514: + return 0x118A0<64> l00000000000174A4: - a2 = 12 - a1 = s1 + 1104 - a0 = s0 - a0 = SEQ(0<32>, memcmp(a0, a1, SLICE(a2, size_t, 0))) - branch a0 != 0<64> l0000000000017408 - // succ: l00000000000174B8 l0000000000017408 + branch CONVERT(memcmp(a0, 0x108D0<64>, SLICE(12, size_t, 0)), uint32, uint64) != 0<64> l0000000000017408 l00000000000174B8: - ra = Mem0[sp + 40:word64] - a0 = 0x12000<64> - a0 = a0 + -1864 - s0 = Mem0[sp + 32:word64] - s1 = Mem0[sp + 24:word64] - s2 = Mem0[sp + 16:word64] - s3 = Mem0[sp + 8:word64] - sp = sp + 48 - return - // succ: fn00000000000173D4_exit -l00000000000174DC: - s1 = 0x10000<64> - s1 = s1 + 1152 - a2 = 16 - a1 = s1 + 1024 - a0 = SEQ(0<32>, memcmp(a0, a1, SLICE(a2, size_t, 0))) - branch a0 == 0<64> l0000000000017538 - // succ: l00000000000174F4 l0000000000017538 -l00000000000174F4: - a2 = 16 - a1 = s1 + 1048 - a0 = s0 - a0 = SEQ(0<32>, memcmp(a0, a1, SLICE(a2, size_t, 0))) - branch a0 != 0<64> l000000000001747C - // succ: l0000000000017508 l000000000001747C -l0000000000017508: - a0 = 0x12000<64> - a0 = a0 + -1936 - goto l0000000000017458 - // succ: l0000000000017458 -l0000000000017514: - ra = Mem0[sp + 40:word64] - a0 = 0x12000<64> - a0 = a0 + -1888 - s0 = Mem0[sp + 32:word64] - s1 = Mem0[sp + 24:word64] - s2 = Mem0[sp + 16:word64] - s3 = Mem0[sp + 8:word64] - sp = sp + 48 - return - // succ: fn00000000000173D4_exit -l0000000000017538: - ra = Mem0[sp + 40:word64] - a0 = 0x12000<64> - a0 = a0 + -1960 - s0 = Mem0[sp + 32:word64] - s1 = Mem0[sp + 24:word64] - s2 = Mem0[sp + 16:word64] - s3 = Mem0[sp + 8:word64] - sp = sp + 48 - return - // succ: fn00000000000173D4_exit -l000000000001755C: - ra = Mem0[sp + 40:word64] - a0 = 0x12000<64> - a0 = a0 + -1912 - s0 = Mem0[sp + 32:word64] - s1 = Mem0[sp + 24:word64] - s2 = Mem0[sp + 16:word64] - s3 = Mem0[sp + 8:word64] - sp = sp + 48 - return - // succ: fn00000000000173D4_exit + return 0x118B8<64> +l0000000000017408: + a5_87 = s2_17 << 8 | s3_18 + branch (a5_87 & 0xFFFFE000<64>) == 0x2000<64> l0000000000017580 l0000000000017580: - a0 = 0x12000<64> - a0 = a0 + -1832 - goto l0000000000017458 - // succ: l0000000000017458 + a0_102 = 0x118D8<64> +l0000000000017420: + branch (s2_17 & 254) == 252 l000000000001758C l000000000001758C: - a0 = 0x12000<64> - a0 = a0 + -1816 - goto l0000000000017458 - // succ: l0000000000017458 + a0_102 = 0x118E8<64> +l000000000001742C: + branch (a5_87 & -64) == 65152 l0000000000017598 l0000000000017598: - a0 = 0x12000<64> - a0 = a0 + -1792 - goto l0000000000017458 - // succ: l0000000000017458 + a0_102 = 0x11900<64> +l000000000001743C: + branch s2_17 == 255 l00000000000175A4 l00000000000175A4: - a0 = 0x11000<64> - a0 = a0 + 1864 - goto l0000000000017458 - // succ: l0000000000017458 + a0_102 = 0x11748<64> +l0000000000017444: + a0_102 = 0x11710<64> + branch (a5_87 & -2) == 8194 l00000000000175B0 l00000000000175B0: - a0 = 0x12000<64> - a0 = a0 + -1768 - goto l0000000000017458 - // succ: l0000000000017458 + a0_102 = 0x11918<64> +l0000000000017458: + return a0_102 fn00000000000173D4_exit: -// fn00000000000175BC -// Return size: 0 -define fn00000000000175BC +word64 fn00000000000175BC(word64 ra, word64 gp, word64 s1, word64 a0, word64 a1, word64 a2, word64 a3, ptr64 & a4Out) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// Called from: +// fn0000000000015180 +// MayUse: a0:[0..63] a1:[0..63] a2:[0..63] a3:[0..63] gp:[0..63] ra:[0..63] s1:[0..63] +// LiveOut: a0:[0..63]-fn0000000000015180 a4:[0..63]-fn0000000000015180 +// Trashed: a0 a1 a2 a4 a5 +// Preserved: a3 a6 a7 fa3 fa4 fa5 gp ra s0 s1 s2 s3 s4 s5 s6 s7 s8 s9 sp t1 t3 t4 t5 fn00000000000175BC_entry: - sp = fp - // succ: l00000000000175BC l00000000000175BC: - sp = sp + -416 - Mem0[sp + 392:word64] = s1 - a5 = Mem0[gp + -1936:word64] - Mem0[sp + 400:word64] = s0 - s0 = a2 - Mem0[sp + 384:word64] = s2 - Mem0[sp + 368:word64] = s4 - a2 = 200 - s4 = a0 - s2 = a1 - a0 = s0 - a1 = 0 - Mem0[sp + 352:word64] = s6 - Mem0[sp + 408:word64] = ra - Mem0[sp + 376:word64] = s3 - Mem0[sp + 360:word64] = s5 - Mem0[sp + 344:word64] = s7 - Mem0[sp + 336:word64] = s8 - Mem0[sp + 328:word64] = s9 - s6 = a3 - Mem0[sp + 312:word64] = a5 - a0 = memset(a0, SLICE(a1, int32, 0), SLICE(a2, size_t, 0)) - a2 = sp + 8 - a1 = s4 - a0 = 10 - a0 = SEQ(0<32>, inet_pton(SLICE(a0, int32, 0), a1, a2)) - branch 0<64> >= a0 l00000000000177B4 - // succ: l0000000000017628 l00000000000177B4 + a5_7 = Mem5[gp + -1936:word64] + memset(a2, 0, SLICE(200, size_t, 0)) + s0_11 = a2 + s4_18 = a0 + s2_20 = a1 + s6_269 = a3 + branch CONVERT(inet_pton(10, a0, &qwLoc0198), uint32, uint64) <= 0<64> l00000000000177B4 +l00000000000177B4: + branch CONVERT(Mem39[gp + -2028:int32], int32, int64) != 0<64> l0000000000017770 +l00000000000177BC: + __fprintf_chk(Mem39[gp + -1920:word64], 1, 0x11920<64>, a0) + a0_101 = -1 l0000000000017628: - a0 = sp + 8 - call fn00000000000163B0 (retsize: 0;) - s3 = sp + 56 - Mem0[s0 + 8:word64] = a0 - a3 = 250 - a2 = s3 - a1 = sp + 8 - a0 = 10 - a0 = inet_ntop(SLICE(a0, int32, 0), a1, a2, SLICE(a3, socklen_t, 0)) - branch a0 == 0<64> l0000000000017768 - // succ: l0000000000017650 l0000000000017768 + Mem61[a2 + 8:word64] = fn00000000000163B0(gp, &qwLoc0198) + s3_266 = &bLoc0168 + branch inet_ntop(10, &qwLoc0198, &bLoc0168, 250) == 0<64> l0000000000017768 l0000000000017650: - a0 = s3 - a0 = __strdup(a0) - Mem0[s0:word64] = a0 - s5 = 128 - branch s5 < s2 l00000000000177DC - // succ: l0000000000017664 l00000000000177DC + Mem69[a2:word64] = __strdup(&bLoc0168) + s5_70 = 128 + branch a1 > 128 l00000000000177DC +l00000000000177DC: + branch CONVERT(Mem69[gp + -2028:int32], int32, int64) != 0<64> l0000000000017770 +l00000000000177E4: + __fprintf_chk(Mem69[gp + -1920:word64], 1, 0x11940<64>, SLICE(a1, int32, 0)) + a0_101 = -1 l0000000000017664: - branch s2 < 0<64> l0000000000017868 - // succ: l0000000000017668 l0000000000017868 + branch a1 < 0<64> l0000000000017868 +l0000000000017868: + s2_20 = 128 l0000000000017668: - s5 = s2 - // succ: l000000000001766C + s5_70 = a1 l000000000001766C: - s7 = sp + 24 - Mem0[s0 + 160:word32] = SLICE(s5, word32, 0) - a1 = s7 - a0 = s5 - call fn000000000001730C (retsize: 0;) - Mem0[s0 + 48:word64] = a0 - branch a0 == 0<64> l00000000000178F8 - // succ: l0000000000017688 l00000000000178F8 + Mem85[a2 + 160:word32] = SLICE(s5_70, word32, 0) + a0_89 = fn000000000001730C(gp, s5_70, &qwLoc0188) + Mem92[a2 + 48:word64] = a0_89 + branch a0_89 == 0<64> l00000000000178F8 +l00000000000178F8: + branch CONVERT(Mem92[gp + -2028:int32], int32, int64) != 0<64> l0000000000017770 +l0000000000017900: + __fprintf_chk(Mem92[gp + -1920:word64], 1, 0x11960<64>, SLICE(s2_20, int32, 0)) + a0_101 = -1 l0000000000017688: - s8 = sp + 40 - a5 = sp + 8 - s9 = s7 - a2 = s8 - a3 = s7 - // succ: l000000000001769C + s8_102 = &qwLoc0178 + a5_103 = &qwLoc0198 + s9_104 = &qwLoc0188 + a2_105 = &qwLoc0178 + a3_106 = &qwLoc0188 l000000000001769C: - a4 = CONVERT(Mem0[a5:byte], byte, word64) - a1 = CONVERT(Mem0[a3:byte], byte, word64) - a5 = a5 + 1 - a3 = a3 + 1 - a4 = a4 & a1 - Mem0[a2:byte] = SLICE(a4, byte, 0) - a2 = a2 + 1 - branch s7 != a5 l000000000001769C - // succ: l00000000000176BC l000000000001769C + Mem116[a2_105:byte] = Mem108[a5_103:byte] & Mem108[a3_106:byte] + a5_103 = a5_103 + 1 + a3_106 = a3_106 + 1 + a2_105 = a2_105 + 1 + branch &qwLoc0188 != a5_103 l000000000001769C l00000000000176BC: - a3 = 250 - a2 = s3 - a1 = sp + 40 - a0 = 10 - a0 = inet_ntop(SLICE(a0, int32, 0), a1, a2, SLICE(a3, socklen_t, 0)) - branch a0 == 0<64> l0000000000017768 - // succ: l00000000000176D4 l0000000000017768 + branch inet_ntop(10, &qwLoc0178, &bLoc0168, 250) == 0<64> l0000000000017768 l00000000000176D4: - a0 = s3 - a0 = __strdup(a0) - Mem0[s0 + 32:word64] = a0 - a0 = sp + 40 - call fn00000000000163B0 (retsize: 0;) - Mem0[s0 + 16:word64] = a0 - a1 = s2 - a0 = sp + 40 - call fn00000000000173D4 (retsize: 0;) - Mem0[s0 + 184:word64] = a0 - a1 = s5 - a0 = sp + 40 - call fn0000000000018118 (retsize: 0;) - Mem0[s0 + 24:word64] = a0 - a5 = 128 - branch s2 != a5 l0000000000017870 - // succ: l0000000000017714 l0000000000017870 + Mem130[a2 + 32:word64] = __strdup(&bLoc0168) + Mem139[a2 + 16:word64] = fn00000000000163B0(gp, &qwLoc0178) + Mem149[a2 + 184:word64] = fn00000000000173D4(&qwLoc0178, s2_20) + Mem157[a2 + 24:word64] = fn0000000000018118(gp, &qwLoc0178, s5_70) + branch s2_20 != 128 l0000000000017870 +l0000000000017870: + Mem161[a2 + 168:word64] = __strdup(&bLoc0168) +l000000000001787C: + s8_102 = s8_102 + 1 + Mem170[s8_102 + -1:byte] = SLICE(~CONVERT(Mem163[s9_104:byte], byte, word64), byte, 0) | Mem163[s8_102:byte] + s9_104 = s9_104 + 1 + branch &bLoc0168 != s8_102 l000000000001787C +l000000000001789C: + branch inet_ntop(10, &qwLoc0178, &bLoc0168, 250) == 0<64> l0000000000017768 +l0000000000017768: + branch CONVERT(Mem181[gp + -2028:int32], int32, int64) == 0<64> l0000000000017804 +l0000000000017804: + fwrite(0x117F8<64>, SLICE(1, size_t, 0), SLICE(43, size_t, 0), Mem181[gp + -1920:word64]) + a0_101 = -1 +l00000000000178B4: + Mem194[a2 + 176:word64] = __strdup(&bLoc0168) + branch CONVERT(0x80<32> - SLICE(s2_20, word32, 0), word32, int64) != 128 l0000000000017728 +l00000000000178D0: l0000000000017714: - a5 = Mem0[s0 + 32:word64] - a0 = s0 + 96 - s2 = 0 - Mem0[s0 + 168:word64] = a5 - Mem0[s0 + 176:word64] = a5 - // succ: l0000000000017728 + a5_202 = Mem157[a2 + 32:word64] + Mem205[a2 + 168:word64] = a5_202 + Mem206[a2 + 176:word64] = a5_202 l0000000000017728: - s2 = s2 << 0x20 - a5 = 0x10000<64> - s2 = s2 >>u 0x1D - a5 = a5 + 1152 - s2 = a5 + s2 - a3 = Mem0[s2:word64] - // succ: l0000000000017740 l0000000000017740: - a2 = 0x12000<64> - a2 = a2 + -1648 - a1 = 64 - a0 = SEQ(0<32>, snprintf(a0, SLICE(a1, size_t, 0), a2, 0<32>)) - a5 = s6 << 0x31 - branch a5 < 0<64> l00000000000178DC - // succ: l0000000000017758 l00000000000178DC + snprintf(a2 + 96, SLICE(64, size_t, 0), 0x11990<64>, 0<32>) + branch a3 << 0x31 < 0<64> l00000000000178DC +l00000000000178DC: + gp = fn0000000000017D10(ra, gp, s1, &qwLoc0198, a2 + 64, a2 + 72, a2 + 80, a2 + 88, a3, &qwLoc0188, out s0_11, out s3_266, out s4_18, out s6_269) l0000000000017758: - s6 = s6 & 1 - branch s6 != 0<64> l0000000000017824 - // succ: l0000000000017760 l0000000000017824 -l0000000000017760: - a0 = 0 - goto l0000000000017774 - // succ: l0000000000017774 -l0000000000017768: - a5 = CONVERT(Mem0[gp + -2028:int32], int32, int64) - branch a5 == 0<64> l0000000000017804 - // succ: l0000000000017770 l0000000000017804 -l0000000000017770: - a0 = -1 - // succ: l0000000000017774 -l0000000000017774: - a4 = Mem0[sp + 312:word64] - a5 = Mem0[gp + -1936:word64] - branch a4 != a5 l0000000000017920 - // succ: l0000000000017780 l0000000000017920 -l0000000000017780: - ra = Mem0[sp + 408:word64] - s0 = Mem0[sp + 400:word64] - s1 = Mem0[sp + 392:word64] - s2 = Mem0[sp + 384:word64] - s3 = Mem0[sp + 376:word64] - s4 = Mem0[sp + 368:word64] - s5 = Mem0[sp + 360:word64] - s6 = Mem0[sp + 352:word64] - s7 = Mem0[sp + 344:word64] - s8 = Mem0[sp + 336:word64] - s9 = Mem0[sp + 328:word64] - sp = sp + 416 - return - // succ: fn00000000000175BC_exit -l00000000000177B4: - a5 = CONVERT(Mem0[gp + -2028:int32], int32, int64) - branch a5 != 0<64> l0000000000017770 - // succ: l00000000000177BC l0000000000017770 -l00000000000177BC: - a0 = Mem0[gp + -1920:word64] - a2 = 0x12000<64> - a3 = s4 - a2 = a2 + -1760 - a1 = 1 - a0 = SEQ(0<32>, __fprintf_chk(a0, SLICE(a1, int32, 0), a2, a3)) - a0 = -1 - goto l0000000000017774 - // succ: l0000000000017774 -l00000000000177DC: - a5 = CONVERT(Mem0[gp + -2028:int32], int32, int64) - branch a5 != 0<64> l0000000000017770 - // succ: l00000000000177E4 l0000000000017770 -l00000000000177E4: - a0 = Mem0[gp + -1920:word64] - a2 = 0x12000<64> - a3 = s2 - a2 = a2 + -1728 - a1 = 1 - a0 = SEQ(0<32>, __fprintf_chk(a0, SLICE(a1, int32, 0), a2, SLICE(a3, int32, 0))) - a0 = -1 - goto l0000000000017774 - // succ: l0000000000017774 -l0000000000017804: - a3 = Mem0[gp + -1920:word64] - a0 = 0x11000<64> - a2 = 43 - a1 = 1 - a0 = a0 + 2040 - a0 = SEQ(0<64>, fwrite(a0, SLICE(a1, size_t, 0), SLICE(a2, size_t, 0), a3)) - a0 = -1 - goto l0000000000017774 - // succ: l0000000000017774 + branch (s6_269 & 1) != 0<64> l0000000000017824 l0000000000017824: - a1 = sp + 8 - a0 = 10 - call fn00000000000168E4 (retsize: 0;) - Mem0[s0 + 56:word64] = a0 - branch a0 != 0<64> l0000000000017760 - // succ: l0000000000017838 l0000000000017760 + a0_278 = fn00000000000168E4(gp, 10, &qwLoc0198) + Mem291[s0_11 + 56:word64] = a0_278 + branch a0_278 != 0<64> l0000000000017760 l0000000000017838: - a5 = CONVERT(Mem0[gp + -2028:int32], int32, int64) - branch a5 != 0<64> l0000000000017770 - // succ: l0000000000017840 l0000000000017770 + branch CONVERT(Mem291[gp + -2028:int32], int32, int64) != 0<64> l0000000000017770 l0000000000017840: - a3 = 0x12000<64> - a4 = s4 - a3 = a3 + -2000 - a2 = 250 - a1 = 1 - a0 = s3 - a0 = SEQ(0<32>, __sprintf_chk(a0, SLICE(a1, int32, 0), SLICE(a2, size_t, 0), a3, a4)) - a0 = s3 - herror(a0) - goto l0000000000017770 - // succ: l0000000000017770 -l0000000000017868: - s2 = s5 - goto l000000000001766C - // succ: l000000000001766C -l0000000000017870: - a0 = s3 - a0 = __strdup(a0) - Mem0[s0 + 168:word64] = a0 - // succ: l000000000001787C -l000000000001787C: - a5 = CONVERT(Mem0[s9:byte], byte, word64) - a4 = CONVERT(Mem0[s8:byte], byte, word64) - s8 = s8 + 1 - a5 = a5 ^ -1 - a5 = a5 | a4 - Mem0[s8 + -1:byte] = SLICE(a5, byte, 0) - s9 = s9 + 1 - branch s3 != s8 l000000000001787C - // succ: l000000000001789C l000000000001787C -l000000000001789C: - a3 = 250 - a2 = s3 - a1 = sp + 40 - a0 = 10 - a0 = inet_ntop(SLICE(a0, int32, 0), a1, a2, SLICE(a3, socklen_t, 0)) - branch a0 == 0<64> l0000000000017768 - // succ: l00000000000178B4 l0000000000017768 -l00000000000178B4: - a0 = s3 - a0 = __strdup(a0) - a5 = 128 - Mem0[s0 + 176:word64] = a0 - v26 = SLICE(a5, word32, 0) - v27 = SLICE(s2, word32, 0) - s2 = CONVERT(v26 - v27, word32, int64) - a0 = s0 + 96 - branch s2 != a5 l0000000000017728 - // succ: l00000000000178D0 l0000000000017728 -l00000000000178D0: - a3 = 0x11000<64> - a3 = a3 + 464 - goto l0000000000017740 - // succ: l0000000000017740 -l00000000000178DC: - a4 = s0 + 88 - a3 = s0 + 80 - a2 = s0 + 72 - a1 = s0 + 64 - a0 = sp + 8 - call fn0000000000017D10 (retsize: 0;) - goto l0000000000017758 - // succ: l0000000000017758 -l00000000000178F8: - a5 = CONVERT(Mem0[gp + -2028:int32], int32, int64) - branch a5 != 0<64> l0000000000017770 - // succ: l0000000000017900 l0000000000017770 -l0000000000017900: - a0 = Mem0[gp + -1920:word64] - a2 = 0x12000<64> - a3 = s2 - a2 = a2 + -1696 - a1 = 1 - a0 = SEQ(0<32>, __fprintf_chk(a0, SLICE(a1, int32, 0), a2, SLICE(a3, int32, 0))) - a0 = -1 - goto l0000000000017774 - // succ: l0000000000017774 + __sprintf_chk(s3_266, 1, SLICE(250, size_t, 0), 0x11830<64>, s4_18) + herror(s3_266) +l0000000000017770: + a0_101 = -1 +l0000000000017760: + a0_101 = 0 +l0000000000017774: + branch a5_7 != Mem316[gp + -1936:word64] l0000000000017920 l0000000000017920: __stack_chk_fail() +l0000000000017780: + a4Out = a5_7 + return a0_101 fn00000000000175BC_exit: -// fn0000000000017924 -// Return size: 0 -define fn0000000000017924 +word64 fn0000000000017924(word64 gp, ptr64 & a1Out, ptr64 & a2Out, ptr64 & a3Out, ptr64 & a4Out, ptr64 & a6Out) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// Called from: +// fn0000000000015180 +// fn0000000000017B40 +// fn0000000000017D10 +// MayUse: gp:[0..63] +// LiveOut: a0:[0..63]-fn0000000000015180 a1:[0..63]-fn0000000000017D10 a2:[0..63]-fn0000000000017D10 a3:[0..63]-fn0000000000017D10 a4:[0..63]-fn0000000000017D10 a6:[0..63]-fn0000000000015180 +// Trashed: a0 a1 a2 a3 a4 a5 a6 +// Preserved: ra s0 s1 s2 s3 s4 s5 s6 s7 s8 s9 sp fn0000000000017924_entry: - sp = fp - // succ: l0000000000017924 l0000000000017924: - sp = sp + -96 - Mem0[sp + 64:word64] = s2 - a5 = Mem0[gp + -2016:word64] - Mem0[sp + 72:word64] = s1 - Mem0[sp + 88:word64] = ra - Mem0[sp + 80:word64] = s0 - Mem0[sp + 56:word64] = s3 - Mem0[sp + 48:word64] = s4 - Mem0[sp + 40:word64] = s5 - Mem0[sp + 32:word64] = s6 - Mem0[sp + 24:word64] = s7 - Mem0[sp + 16:word64] = s8 - Mem0[sp + 8:word64] = s9 - branch a5 == 0<64> l00000000000179B8 - // succ: l000000000001795C l00000000000179B8 -l000000000001795C: - a5 = CONVERT(Mem0[gp + -2028:int32], int32, int64) - branch a5 != 0<64> l000000000001796C - // succ: l0000000000017964 l000000000001796C -l0000000000017964: - a5 = CONVERT(Mem0[gp + -800:byte], byte, word64) - branch a5 != 0<64> l00000000000179A8 - // succ: l000000000001796C l00000000000179A8 -l000000000001796C: - s0 = CONVERT(Mem0[gp + -2024:int32], int32, int64) - // succ: l0000000000017970 -l0000000000017970: - ra = Mem0[sp + 88:word64] - a0 = s0 - s1 = Mem0[sp + 72:word64] - s0 = Mem0[sp + 80:word64] - s2 = Mem0[sp + 64:word64] - s3 = Mem0[sp + 56:word64] - s4 = Mem0[sp + 48:word64] - s5 = Mem0[sp + 40:word64] - s6 = Mem0[sp + 32:word64] - s7 = Mem0[sp + 24:word64] - s8 = Mem0[sp + 16:word64] - s9 = Mem0[sp + 8:word64] - sp = sp + 96 - return - // succ: fn0000000000017924_exit -l00000000000179A8: - a1 = Mem0[gp + -1920:word64] - a0 = gp + -800 - a0 = SEQ(0<32>, fputs(a0, a1)) - goto l000000000001796C - // succ: l000000000001796C + branch Mem5[gp + -2016:word64] == 0<64> l00000000000179B8 l00000000000179B8: - s0 = CONVERT(Mem0[gp + -2024:int32], int32, int64) - branch s0 != 0<64> l000000000001795C - // succ: l00000000000179C0 l000000000001795C + s0_107 = CONVERT(Mem27[gp + -2024:int32], int32, int64) + branch s0_107 != 0<64> l000000000001795C l00000000000179C0: - s4 = 0x13000<64> - a1 = 1 - a0 = s4 + -1480 - a0 = dlopen(a0, SLICE(a1, int32, 0)) - Mem0[gp + -2016:word64] = a0 - s3 = a0 - branch a0 == 0<64> l0000000000017B14 - // succ: l00000000000179DC l0000000000017B14 + a0_32 = dlopen(0x12A38<64>, 1) + Mem33[gp + -2016:word64] = a0_32 + branch a0_32 == 0<64> l0000000000017B14 +l0000000000017B14: + __snprintf_chk(gp + -800, SLICE(256, size_t, 0), 1, SLICE(256, size_t, 0), 0x12A58<64>, 0x12A38<64>) + Mem44[gp + -2024:word32] = 0xFFFFFFFF<32> + a3 = 256 + a4 = 0x12A58<64> + a2 = 1 + a1 = 256 + s0_107 = -1 l00000000000179DC: - a1 = 0x13000<64> - a1 = a1 + -1416 - a0 = dlsym(a0, a1) - a1 = 0x13000<64> - Mem0[gp + -1944:word64] = a0 - a1 = a1 + -1392 - a0 = s3 - a0 = dlsym(a0, a1) - a1 = 0x13000<64> - s2 = a0 - a1 = a1 + -1376 - a0 = s3 - Mem0[gp + -1952:word64] = s2 - a0 = dlsym(a0, a1) - a1 = 0x13000<64> - s4 = a0 - a1 = a1 + -1344 - a0 = s3 - Mem0[gp + -1960:word64] = s4 - a0 = dlsym(a0, a1) - a1 = 0x13000<64> - s5 = a0 - a1 = a1 + -1328 - a0 = s3 - Mem0[gp + -1976:word64] = s5 - a0 = dlsym(a0, a1) - a1 = 0x13000<64> - s6 = a0 - a1 = a1 + -1304 - a0 = s3 - Mem0[gp + -1984:word64] = s6 - a0 = dlsym(a0, a1) - a1 = 0x13000<64> - s7 = a0 - a1 = a1 + -1280 - a0 = s3 - Mem0[gp + -1992:word64] = s7 - a0 = dlsym(a0, a1) - a1 = 0x13000<64> - s8 = a0 - a1 = a1 + -1256 - a0 = s3 - Mem0[gp + -2000:word64] = s8 - a0 = dlsym(a0, a1) - a1 = 0x13000<64> - s9 = a0 - a1 = a1 + -1224 - a0 = s3 - Mem0[gp + -2008:word64] = s9 - a0 = dlsym(a0, a1) - Mem0[gp + -1968:word64] = a0 - branch s2 == 0<64> l0000000000017ACC - // succ: l0000000000017AAC l0000000000017ACC + Mem49[gp + -1944:word64] = dlsym(a0_32, 0x12A78<64>) + a0_52 = dlsym(a0_32, 0x12A90<64>) + Mem57[gp + -1952:word64] = a0_52 + a0_58 = dlsym(a0_32, 0x12AA0<64>) + Mem63[gp + -1960:word64] = a0_58 + a0_64 = dlsym(a0_32, 0x12AC0<64>) + Mem69[gp + -1976:word64] = a0_64 + a0_70 = dlsym(a0_32, 0x12AD0<64>) + Mem75[gp + -1984:word64] = a0_70 + a0_76 = dlsym(a0_32, 0x12AE8<64>) + Mem81[gp + -1992:word64] = a0_76 + a0_82 = dlsym(a0_32, 0x12B00<64>) + Mem87[gp + -2000:word64] = a0_82 + a0_88 = dlsym(a0_32, 0x12B18<64>) + Mem93[gp + -2008:word64] = a0_88 + Mem95[gp + -1968:word64] = dlsym(a0_32, 0x12B38<64>) + a1 = 0x12B38<64> + branch a0_52 == 0<64> l0000000000017ACC l0000000000017AAC: - branch s4 == 0<64> l0000000000017ACC - // succ: l0000000000017AB0 l0000000000017ACC + branch a0_58 == 0<64> l0000000000017ACC l0000000000017AB0: - branch s5 == 0<64> l0000000000017ACC - // succ: l0000000000017AB4 l0000000000017ACC + branch a0_64 == 0<64> l0000000000017ACC l0000000000017AB4: - branch s6 == 0<64> l0000000000017ACC - // succ: l0000000000017AB8 l0000000000017ACC + branch a0_70 == 0<64> l0000000000017ACC l0000000000017AB8: - branch s7 == 0<64> l0000000000017ACC - // succ: l0000000000017ABC l0000000000017ACC + branch a0_76 == 0<64> l0000000000017ACC l0000000000017ABC: - branch s8 == 0<64> l0000000000017ACC - // succ: l0000000000017AC0 l0000000000017ACC + branch a0_82 == 0<64> l0000000000017ACC l0000000000017AC0: - branch s9 == 0<64> l0000000000017ACC - // succ: l0000000000017AC4 l0000000000017ACC -l0000000000017AC4: - Mem0[gp + -2024:word32] = SLICE(0<64>, word32, 0) - goto l0000000000017970 - // succ: l0000000000017970 + branch a0_88 == 0<64> l0000000000017ACC l0000000000017ACC: - a4 = 0x13000<64> - a5 = a4 + -1200 - a6 = Mem0[a4 + -1200:word64] - a0 = Mem0[a5 + 8:word64] - a1 = Mem0[a5 + 16:word64] - a2 = Mem0[a5 + 24:word64] - a3 = Mem0[a5 + 32:word64] - a4 = CONVERT(Mem0[a5 + 40:int32], int32, int64) - a5 = gp + -800 - s0 = -1 - Mem0[a5:word64] = a6 - Mem0[a5 + 8:word64] = a0 - Mem0[a5 + 16:word64] = a1 - Mem0[a5 + 24:word64] = a2 - Mem0[a5 + 32:word64] = a3 - Mem0[a5 + 40:word32] = SLICE(a4, word32, 0) - Mem0[gp + -2024:word32] = SLICE(s0, word32, 0) - goto l0000000000017970 - // succ: l0000000000017970 -l0000000000017B14: - a3 = 256 - a4 = 0x13000<64> - a5 = s4 + -1480 - a4 = a4 + -1448 - a2 = 1 - a1 = a3 - a0 = gp + -800 - s0 = -1 - a0 = SEQ(0<32>, __snprintf_chk(a0, SLICE(a1, size_t, 0), SLICE(a2, int32, 0), SLICE(a3, size_t, 0), a4, a5)) - Mem0[gp + -2024:word32] = SLICE(s0, word32, 0) - goto l0000000000017970 - // succ: l0000000000017970 + a6 = Mem95[0x12B50<64>:word64] + a0_100 = Mem95[0x12B58<64>:word64] + a1 = Mem95[0x12B60<64>:word64] + a2 = Mem95[0x12B68<64>:word64] + a3 = Mem95[0x12B70<64>:word64] + a4 = CONVERT(Mem95[0x12B78<64>:int32], int32, int64) + Mem108[gp + -800:word64] = a6 + Mem109[gp + -792:word64] = a0_100 + Mem110[gp + -784:word64] = a1 + Mem111[gp + -776:word64] = a2 + Mem112[gp + -768:word64] = a3 + Mem113[gp + -760:word32] = SLICE(a4, word32, 0) + Mem114[gp + -2024:word32] = 0xFFFFFFFF<32> + s0_107 = -1 +l0000000000017AC4: + Mem115[gp + -2024:word32] = 0<32> +l000000000001795C: + branch CONVERT(Mem27[gp + -2028:int32], int32, int64) != 0<64> l000000000001796C +l0000000000017964: + branch CONVERT(Mem27[gp + -800:byte], byte, word64) != 0<64> l00000000000179A8 +l00000000000179A8: + a1 = Mem27[gp + -1920:word64] + fputs(gp + -800, a1) +l000000000001796C: + s0_107 = CONVERT(Mem27[gp + -2024:int32], int32, int64) +l0000000000017970: + a1Out = a1 + a2Out = a2 + a3Out = a3 + a4Out = a4 + a6Out = a6 + return s0_107 fn0000000000017924_exit: -// fn0000000000017B40 -// Return size: 0 -define fn0000000000017B40 +word64 fn0000000000017B40(word64 ra, word64 gp, word64 a0, word64 a1, word64 a2, word64 a3, word64 a4, word64 s5, word64 s6, ptr64 & s1Out, ptr64 & s6Out) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// Called from: +// fn0000000000016D74 +// MayUse: a0:[0..63] a1:[0..63] a2:[0..63] a3:[0..63] a4:[0..63] gp:[0..63] ra:[0..63] s5:[0..63] s6:[0..63] +// LiveOut: gp:[0..63]-fn0000000000016D74 s1:[0..63]-fn0000000000016D74 s6:[0..63]-fn0000000000016D74 +// Trashed: a0 a1 a2 a3 a4 a5 a6 fa3 fa4 fa5 gp ra s0 s1 s2 s3 s4 s5 s6 s7 t1 +// Preserved: sp fn0000000000017B40_entry: - sp = fp - // succ: l0000000000017B40 l0000000000017B40: - sp = sp + -80 - Mem0[sp + 64:word64] = s0 - Mem0[sp + 56:word64] = s1 - Mem0[sp + 48:word64] = s2 - Mem0[sp + 40:word64] = s3 - Mem0[sp + 32:word64] = s4 - Mem0[sp + 72:word64] = ra - Mem0[sp + 24:word64] = s5 - Mem0[sp + 16:word64] = s6 - Mem0[sp + 8:word64] = s7 - s0 = a0 - s3 = a1 - s2 = a2 - s1 = a3 - s4 = a4 - call fn0000000000017924 (retsize: 0;) - branch a0 == 0<64> l0000000000017BB0 - // succ: l0000000000017B84 l0000000000017BB0 -l0000000000017B84: - ra = Mem0[sp + 72:word64] - s0 = Mem0[sp + 64:word64] - s1 = Mem0[sp + 56:word64] - s2 = Mem0[sp + 48:word64] - s3 = Mem0[sp + 40:word64] - s4 = Mem0[sp + 32:word64] - s5 = Mem0[sp + 24:word64] - s6 = Mem0[sp + 16:word64] - s7 = Mem0[sp + 8:word64] - sp = sp + 80 - return - // succ: fn0000000000017B40_exit + branch fn0000000000017924(gp, out a1_34, out a2_35, out a3_510, out a4_511, out a6_512) == 0<64> l0000000000017BB0 l0000000000017BB0: - a0 = s0 - call fn00000000000182B4 (retsize: 0;) - a5 = Mem0[gp + -1944:word64] - s7 = a0 - call a5 (retsize: 0;) - a5 = Mem0[gp + -1952:word64] - a1 = 16 - a0 = 1 - call a5 (retsize: 0;) - s0 = a0 - branch a0 == 0<64> l0000000000017C3C - // succ: l0000000000017BDC l0000000000017C3C + a0_41 = fn00000000000182B4(a0, out a3_42, out a4_43) + call Mem21[gp + -1944:word64] (retsize: 0;) + uses: a0:a0_41,a1:a1_34,a2:a2_35,a3:a3_42,a4:a4_43,fa3:fa3_92,fa4:fa4_89,fa5:fa5_90,gp:gp,Mem:Mem21,ra:ra,s0:a0,s1:a3,s2:a2,s3:a1,s4:a4,s5:s5,s6:s6,s7:a0_41,t1:t1_91 + defs: a2:a2_59,a3:a3_60,a4:a4_61,gp:gp_62,ra:ra_53,s0:s0_48,s1:s1_49,s2:s2_50,s3:s3_51,s4:s4_52,s5:s5_54,s6:s6_55,s7:s7_56 + call Mem21[gp_62 + -1952:word64] (retsize: 0;) + uses: a0:1,a1:16,a2:a2_59,a3:a3_60,a4:a4_61,fa3:fa3_92,fa4:fa4_89,fa5:fa5_90,gp:gp_62,Mem:Mem21,ra:ra_53,s0:s0_48,s1:s1_49,s2:s2_50,s3:s3_51,s4:s4_52,s5:s5_54,s6:s6_55,s7:s7_56,t1:t1_91 + defs: a0:a0_82,a2:a2_84,a3:a3_85,a4:a4_86,fa3:fa3_92,fa4:fa4_89,fa5:fa5_90,gp:gp_87,ra:ra_78,s1:s1_74,s2:s2_75,s3:s3_76,s4:s4_77,s5:s5_79,s6:s6_80,s7:s7_81,t1:t1_91 + s0_211 = a0_82 + branch a0_82 == 0<64> l0000000000017C3C l0000000000017BDC: - a5 = Mem0[gp + -1992:word64] - a4 = 1 - a1 = s7 << 0x20 - Mem0[a0 + 76:word32] = SLICE(a4, word32, 0) - a1 = a1 >>u 0x20 - call a5 (retsize: 0;) - s6 = a0 - branch a0 < 0<64> l0000000000017B84 - // succ: l0000000000017BFC l0000000000017B84 + a5_95 = Mem21[gp_225 + -1992:word64] + Mem98[a0_82 + 76:word32] = 1<32> + call a5_95 (retsize: 0;) + uses: a0:a0_82,a1:CONVERT(SLICE(s7_81, word32, 0), word32, word64),a2:a2_84,a3:a3_85,a4:1,fa3:fa3_120,fa4:fa4_117,fa5:fa5_118,gp:gp_87,Mem:Mem98,ra:ra_78,s0:a0_82,s1:s1_74,s2:s2_75,s3:s3_76,s4:s4_77,s5:s5_79,s6:s6_80,s7:s7_81,t1:t1_119 + defs: a0:a0_110,a2:a2_112,a3:a3_113,a4:a4_114,fa3:fa3_120,fa4:fa4_117,fa5:fa5_118,gp:gp_115,ra:ra_106,s0:s0_101,s1:s1_102,s2:s2_103,s3:s3_104,s4:s4_105,s5:s5_107,s7:s7_109,t1:t1_119 + branch a0_110 < 0<64> l0000000000017B84 l0000000000017BFC: - a5 = Mem0[gp + -1960:word64] - a1 = a0 - a0 = s0 - call a5 (retsize: 0;) - branch a0 == 0<64> l0000000000017C18 - // succ: l0000000000017C10 l0000000000017C18 + call Mem98[gp + -1960:word64] (retsize: 0;) + uses: a0:s0_101,a1:a0_110,a2:a2_112,a3:a3_113,a4:a4_114,fa3:fa3_146,fa4:fa4_143,fa5:fa5_144,gp:gp_115,Mem:Mem98,ra:ra_106,s0:s0_101,s1:s1_102,s2:s2_103,s3:s3_104,s4:s4_105,s5:s5_107,s6:a0_110,s7:s7_109,t1:t1_145 + defs: a0:a0_136,a1:a1_137,a2:a2_138,a3:a3_139,a4:a4_140,fa3:fa3_146,fa4:fa4_143,fa5:fa5_144,gp:gp_141,ra:ra_132,s0:s0_127,s1:s1_128,s2:s2_129,s3:s3_130,s4:s4_131,s5:s5_133,s6:s6_134,s7:s7_135,t1:t1_145 + branch a0_136 == 0<64> l0000000000017C18 l0000000000017C10: - a0 = __strdup(a0) - Mem0[s3:word64] = a0 - // succ: l0000000000017C18 + Mem149[s3_130:word64] = __strdup(a0_136) l0000000000017C18: - a5 = Mem0[gp + -1968:word64] - a0 = s6 - call a5 (retsize: 0;) - branch a0 == 0<64> l0000000000017C30 - // succ: l0000000000017C28 l0000000000017C30 + call Mem151[gp_141 + -1968:word64] (retsize: 0;) + uses: a0:s6_134,a1:a1_137,a2:a2_138,a3:a3_139,a4:a4_140,fa3:fa3_188,fa4:fa4_185,fa5:fa5_186,gp:gp_141,Mem:Mem151,ra:ra_132,s0:s0_127,s1:s1_128,s2:s2_129,s3:s3_130,s4:s4_131,s5:s5_133,s6:s6_134,s7:s7_135,t1:t1_187 + defs: a0:a0_178,a1:a1_179,a2:a2_180,a3:a3_181,a4:a4_182,fa3:fa3_188,fa4:fa4_185,fa5:fa5_186,gp:gp_183,ra:ra_174,s0:s0_169,s1:s1_170,s2:s2_171,s3:s3_172,s4:s4_173,s5:s5_175,s6:s6_176,s7:s7_177,t1:t1_187 + branch a0_178 == 0<64> l0000000000017C30 l0000000000017C28: - a0 = __strdup(a0) - Mem0[s2:word64] = a0 - // succ: l0000000000017C30 + Mem191[s2_171:word64] = __strdup(a0_178) l0000000000017C30: - a5 = Mem0[gp + -1976:word64] - a0 = s0 - call a5 (retsize: 0;) - // succ: l0000000000017C3C + call Mem193[gp_183 + -1976:word64] (retsize: 0;) + uses: a0:s0_169,a1:a1_179,a2:a2_180,a3:a3_181,a4:a4_182,fa3:fa3_230,fa4:fa4_227,fa5:fa5_228,gp:gp_183,Mem:Mem193,ra:ra_174,s0:s0_169,s1:s1_170,s2:s2_171,s3:s3_172,s4:s4_173,s5:s5_175,s6:s6_176,s7:s7_177,t1:t1_229 + defs: a2:a2_222,a3:a3_223,a4:a4_224,fa3:fa3_230,fa4:fa4_227,fa5:fa5_228,gp:gp_225,ra:ra_216,s0:s0_211,s1:s1_212,s2:s2_213,s3:s3_214,s4:s4_215,s5:s5_217,s6:s6_218,s7:s7_219,t1:t1_229 l0000000000017C3C: - a5 = Mem0[gp + -1952:word64] - a1 = 16 - a0 = 2 - call a5 (retsize: 0;) - s0 = a0 - branch a0 == 0<64> l0000000000017CF4 - // succ: l0000000000017C54 l0000000000017CF4 + call Mem233[gp_225 + -1952:word64] (retsize: 0;) + uses: a0:2,a1:16,a2:a2_246,a3:a3_247,a4:a4_248,fa3:fa3_270,fa4:fa4_267,fa5:fa5_268,gp:gp_232,Mem:Mem233,ra:ra_242,s0:s0_237,s1:s1_238,s2:s2_239,s3:s3_240,s4:s4_241,s5:s5_243,s6:s6_244,s7:s7_245,t1:t1_269 + defs: a0:a0_260,a2:a2_262,a3:a3_263,a4:a4_264,fa3:fa3_270,fa4:fa4_267,fa5:fa5_268,gp:gp_265,ra:ra_256,s1:s1_252,s2:s2_253,s3:s3_254,s4:s4_255,s5:s5_257,s6:s6_258,s7:s7_259,t1:t1_269 + s0_272 = a0_260 + branch a0_260 == 0<64> l0000000000017CF4 +l0000000000017CF4: + call Mem233[gp + -1952:word64] (retsize: 0;) + uses: a0:6,a1:16,a2:a2_262,a3:a3_263,a4:a4_264,fa3:fa3_296,fa4:fa4_293,fa5:fa5_294,gp:gp_265,Mem:Mem233,ra:ra_256,s0:a0_260,s1:s1_252,s2:s2_253,s3:s3_254,s4:s4_255,s5:s5_257,s6:s6_258,s7:s7_259,t1:t1_295 + defs: a0:a0_286,a2:a2_288,a3:a3_289,fa3:fa3_296,fa4:fa4_293,fa5:fa5_294,gp:gp_291,ra:ra_282,s1:s1_278,s2:s2_279,s3:s3_280,s4:s4_281,s5:s5_283,s6:s6_284,s7:s7_285,t1:t1_295 + s0_272 = a0_260 + branch a0_260 != 0<64> l0000000000017C54 +l0000000000017D0C: l0000000000017C54: - a5 = Mem0[gp + -1984:word64] - a4 = 1 - a1 = s7 << 0x20 - Mem0[s0 + 76:word32] = SLICE(a4, word32, 0) - a1 = a1 >>u 0x20 - call a5 (retsize: 0;) - s2 = a0 - branch a0 == 0<64> l0000000000017C94 - // succ: l0000000000017C74 l0000000000017C94 + a5_301 = Mem233[gp + -1984:word64] + Mem306[s0_272 + 76:word32] = 1<32> + call a5_301 (retsize: 0;) + uses: a0:a0_315,a1:CONVERT(SLICE(s7_303, word32, 0), word32, word64),a2:a2_316,a3:a3_317,a4:1,fa3:fa3_339,fa4:fa4_336,fa5:fa5_337,gp:gp_299,Mem:Mem306,ra:ra_312,s0:s0_305,s1:s1_308,s2:s2_309,s3:s3_310,s4:s4_311,s5:s5_313,s6:s6_314,s7:s7_303,t1:t1_338 + defs: a0:a0_329,a1:a1_330,a2:a2_331,a3:a3_332,a4:a4_333,fa3:fa3_339,fa4:fa4_336,fa5:fa5_337,gp:gp_334,s0:s0_320,s1:s1_321,s4:s4_324,sp:sp_319,t1:t1_338 + branch a0_329 == 0<64> l0000000000017C94 l0000000000017C74: - a0 = Mem0[a0 + 32:word64] - branch a0 == 0<64> l0000000000017C84 - // succ: l0000000000017C7C l0000000000017C84 + a0_342 = Mem306[a0_329 + 32:word64] + branch a0_342 == 0<64> l0000000000017C84 l0000000000017C7C: - a0 = __strdup(a0) - Mem0[s1:word64] = a0 - // succ: l0000000000017C84 + Mem344[s1_321:word64] = __strdup(a0_342) l0000000000017C84: - fa4 = SEQ(0xFFFFFFFF<32>, Mem0[s2 + 52:real32]) - v23 = SLICE(0<64>, int32, 0) - fa5 = SEQ(0xFFFFFFFF<32>, v23) - a5 = CONVERT(SLICE(fa4, real32, 0) == SLICE(fa5, real32, 0), bool, word64) - branch a5 == 0<64> l0000000000017CC8 - // succ: l0000000000017C94 l0000000000017CC8 -l0000000000017C94: - a0 = s0 - ra = Mem0[sp + 72:word64] - s0 = Mem0[sp + 64:word64] - s1 = Mem0[sp + 56:word64] - s2 = Mem0[sp + 48:word64] - s3 = Mem0[sp + 40:word64] - s4 = Mem0[sp + 32:word64] - s5 = Mem0[sp + 24:word64] - s6 = Mem0[sp + 16:word64] - s7 = Mem0[sp + 8:word64] - t1 = Mem0[gp + -1976:word64] - sp = sp + 80 - call t1 (retsize: 0;) - return - // succ: fn0000000000017B40_exit + branch CONVERT(Mem346[a0_329 + 52:real32] == 0.0F, bool, word64) == 0<64> l0000000000017CC8 l0000000000017CC8: - fa5 = SEQ(0xFFFFFFFF<32>, Mem0[s2 + 48:real32]) - fa4 = CONVERT(SLICE(fa4, real32, 0), real32, real64) - a2 = 0x13000<64> - fa5 = CONVERT(SLICE(fa5, real32, 0), real32, real64) - a4 = fa4 - a2 = a2 + -1152 - a3 = fa5 - a1 = 1 - a0 = s4 - a0 = SEQ(0<32>, __asprintf_chk(a0, SLICE(a1, int32, 0), a2, fa3, fa4)) - goto l0000000000017C94 - // succ: l0000000000017C94 -l0000000000017CF4: - a5 = Mem0[gp + -1952:word64] - a1 = 16 - a0 = 6 - call a5 (retsize: 0;) - s0 = a0 - branch a0 != 0<64> l0000000000017C54 - // succ: l0000000000017D0C l0000000000017C54 -l0000000000017D0C: - goto l0000000000017B84 - // succ: l0000000000017B84 + fa4_352 = CONVERT(Mem346[a0_329 + 52:real32], real32, real64) + a3_332 = CONVERT(Mem346[a0_329 + 48:real32], real32, real64) + __asprintf_chk(s4_324, 1, 0x12B80<64>, fa3_339, fa4_352) + a4_333 = fa4_352 + a2_331 = 0x12B80<64> + a1_330 = 1 +l0000000000017C94: + call Mem368[gp_334 + -1976:word64] (retsize: 0;) + uses: a0:s0_320,a1:a1_382,a2:a2_384,a3:a3_386,a4:a4_388,fa3:fa3_410,fa4:fa4_407,fa5:fa5_408,gp:gp_334,Mem:Mem368,ra:Mem368[sp_319 + 72:word64],s0:Mem368[sp_319 + 64:word64],s1:Mem368[sp_319 + 56:word64],s2:Mem368[sp_319 + 48:word64],s3:Mem368[sp_319 + 40:word64],s4:Mem368[sp_319 + 32:word64],s5:Mem368[sp_319 + 24:word64],s6:Mem368[sp_319 + 16:word64],s7:Mem368[sp_319 + 8:word64],t1:t1_409 + defs: fa3:fa3_410,fa4:fa4_407,fa5:fa5_408,gp:gp_405,s1:s1_392,s6:s6_398,t1:t1_409 + s1Out = s1_392 + s6Out = s6_398 + return gp_405 +l0000000000017B84: + s1Out = s1 + s6Out = s6 + return gp fn0000000000017B40_exit: -// fn0000000000017D10 -// Return size: 0 -define fn0000000000017D10 +word64 fn0000000000017D10(word64 ra, word64 gp, word64 s1, word64 a0, word64 a1, word64 a2, word64 a3, word64 a4, word64 s6, word64 s7, ptr64 & s0Out, ptr64 & s3Out, ptr64 & s4Out, ptr64 & s6Out) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// Called from: +// fn00000000000175BC +// MayUse: a0:[0..63] a1:[0..63] a2:[0..63] a3:[0..63] a4:[0..63] gp:[0..63] ra:[0..63] s1:[0..63] s6:[0..63] s7:[0..63] +// LiveOut: gp:[0..63]-fn00000000000175BC s0:[0..63]-fn00000000000175BC s3:[0..63]-fn00000000000175BC s4:[0..63]-fn00000000000175BC s6:[0..63]-fn00000000000175BC +// Trashed: a0 a1 a2 a3 a4 a5 a6 fa3 fa4 fa5 gp ra s0 s1 s2 s3 s4 s5 s6 s7 t1 +// Preserved: sp fn0000000000017D10_entry: - sp = fp - // succ: l0000000000017D10 l0000000000017D10: - sp = sp + -80 - Mem0[sp + 64:word64] = s0 - Mem0[sp + 48:word64] = s2 - Mem0[sp + 40:word64] = s3 - Mem0[sp + 32:word64] = s4 - Mem0[sp + 24:word64] = s5 - Mem0[sp + 72:word64] = ra - Mem0[sp + 56:word64] = s1 - Mem0[sp + 16:word64] = s6 - Mem0[sp + 8:word64] = s7 - s0 = a0 - s4 = a1 - s3 = a2 - s2 = a3 - s5 = a4 - call fn0000000000017924 (retsize: 0;) - branch a0 == 0<64> l0000000000017D80 - // succ: l0000000000017D54 l0000000000017D80 -l0000000000017D54: - ra = Mem0[sp + 72:word64] - s0 = Mem0[sp + 64:word64] - s1 = Mem0[sp + 56:word64] - s2 = Mem0[sp + 48:word64] - s3 = Mem0[sp + 40:word64] - s4 = Mem0[sp + 32:word64] - s5 = Mem0[sp + 24:word64] - s6 = Mem0[sp + 16:word64] - s7 = Mem0[sp + 8:word64] - sp = sp + 80 - return - // succ: fn0000000000017D10_exit + a0_33 = fn0000000000017924(gp, out a1_34, out a2_35, out a3_36, out a4_37, out a6_516) + branch a0_33 == 0<64> l0000000000017D80 l0000000000017D80: - a5 = Mem0[gp + -1944:word64] - call a5 (retsize: 0;) - a5 = Mem0[gp + -1952:word64] - a1 = 16 - a0 = 12 - call a5 (retsize: 0;) - s1 = a0 - branch a0 == 0<64> l0000000000017E18 - // succ: l0000000000017DA0 l0000000000017E18 + call Mem21[gp + -1944:word64] (retsize: 0;) + uses: a0:a0_33,a1:a1_34,a2:a2_35,a3:a3_36,a4:a4_37,fa3:fa3_87,fa4:fa4_84,fa5:fa5_85,gp:gp,Mem:Mem21,ra:ra,s0:a0,s1:s1,s2:a3,s3:a2,s4:a1,s5:a4,s6:s6,s7:s7,t1:t1_86 + defs: a2:a2_53,a3:a3_54,a4:a4_55,gp:gp_56,ra:ra_47,s0:s0_42,s1:s1_48,s2:s2_43,s3:s3_44,s4:s4_45,s5:s5_46,s6:s6_49,s7:s7_50 + call Mem21[gp_56 + -1952:word64] (retsize: 0;) + uses: a0:12,a1:16,a2:a2_53,a3:a3_54,a4:a4_55,fa3:fa3_87,fa4:fa4_84,fa5:fa5_85,gp:gp_56,Mem:Mem21,ra:ra_47,s0:s0_42,s1:s1_48,s2:s2_43,s3:s3_44,s4:s4_45,s5:s5_46,s6:s6_49,s7:s7_50,t1:t1_86 + defs: a0:a0_76,a2:a2_78,a3:a3_79,a4:a4_80,fa3:fa3_87,fa4:fa4_84,fa5:fa5_85,gp:gp_81,ra:ra_72,s0:s0_67,s2:s2_68,s3:s3_69,s4:s4_70,s5:s5_71,s6:s6_74,s7:s7_75,t1:t1_86 + s1_217 = a0_76 + branch a0_76 == 0<64> l0000000000017E18 l0000000000017DA0: - a4 = CONVERT(Mem0[s0 + 4:uint32], uint32, word64) - a5 = CONVERT(Mem0[s0 + 12:uint32], uint32, word64) - a1 = CONVERT(Mem0[s0:uint32], uint32, word64) - a2 = CONVERT(Mem0[s0 + 8:uint32], uint32, word64) - a3 = Mem0[gp + -2000:word64] - a4 = a4 << 0x20 - a5 = a5 << 0x20 - a6 = 1 - Mem0[a0 + 76:word32] = SLICE(a6, word32, 0) - a1 = a4 | a1 - a2 = a5 | a2 - call a3 (retsize: 0;) - s7 = a0 - branch a0 < 0<64> l0000000000017D54 - // succ: l0000000000017DD8 l0000000000017D54 + a4_89 = CONVERT(Mem21[s0_211 + 4:uint32], uint32, word64) + a5_90 = CONVERT(Mem21[s0_211 + 12:uint32], uint32, word64) + a1_91 = CONVERT(Mem21[s0_211:uint32], uint32, word64) + a2_92 = CONVERT(Mem21[s0_211 + 8:uint32], uint32, word64) + a3_93 = Mem21[gp_225 + -2000:word64] + Mem97[a0_76 + 76:word32] = 1<32> + call a3_93 (retsize: 0;) + uses: a0:a0_76,a1:a4_89 << 0x20 | a1_91,a2:a5_90 << 0x20 | a2_92,a3:a3_93,a4:a4_89 << 0x20,a5:a5_90 << 0x20,a6:1,fa3:fa3_121,fa4:fa4_118,fa5:fa5_119,gp:gp_81,Mem:Mem97,ra:ra_72,s0:s0_67,s1:a0_76,s2:s2_68,s3:s3_69,s4:s4_70,s5:s5_71,s6:s6_74,s7:s7_75,t1:t1_120 + defs: a0:a0_110,a2:a2_112,a3:a3_113,a4:a4_114,fa3:fa3_121,fa4:fa4_118,fa5:fa5_119,gp:gp_115,ra:ra_106,s0:s0_101,s1:s1_107,s2:s2_102,s3:s3_103,s4:s4_104,s5:s5_105,s6:s6_108,t1:t1_120 + branch a0_110 < 0<64> l0000000000017D54 l0000000000017DD8: - a5 = Mem0[gp + -1960:word64] - a1 = a0 - a0 = s1 - call a5 (retsize: 0;) - branch a0 == 0<64> l0000000000017DF4 - // succ: l0000000000017DEC l0000000000017DF4 + call Mem97[gp + -1960:word64] (retsize: 0;) + uses: a0:s1_107,a1:a0_110,a2:a2_112,a3:a3_113,a4:a4_114,fa3:fa3_147,fa4:fa4_144,fa5:fa5_145,gp:gp_115,Mem:Mem97,ra:ra_106,s0:s0_101,s1:s1_107,s2:s2_102,s3:s3_103,s4:s4_104,s5:s5_105,s6:s6_108,s7:a0_110,t1:t1_146 + defs: a0:a0_136,a1:a1_137,a2:a2_138,a3:a3_139,a4:a4_140,fa3:fa3_147,fa4:fa4_144,fa5:fa5_145,gp:gp_141,ra:ra_132,s0:s0_127,s1:s1_133,s2:s2_128,s3:s3_129,s4:s4_130,s5:s5_131,s6:s6_134,s7:s7_135,t1:t1_146 + branch a0_136 == 0<64> l0000000000017DF4 l0000000000017DEC: - a0 = __strdup(a0) - Mem0[s4:word64] = a0 - // succ: l0000000000017DF4 + Mem149[s4_130:word64] = __strdup(a0_136) l0000000000017DF4: - a5 = Mem0[gp + -1968:word64] - a0 = s7 - call a5 (retsize: 0;) - branch a0 == 0<64> l0000000000017E0C - // succ: l0000000000017E04 l0000000000017E0C + call Mem151[gp_141 + -1968:word64] (retsize: 0;) + uses: a0:s7_135,a1:a1_137,a2:a2_138,a3:a3_139,a4:a4_140,fa3:fa3_189,fa4:fa4_186,fa5:fa5_187,gp:gp_141,Mem:Mem151,ra:ra_132,s0:s0_127,s1:s1_133,s2:s2_128,s3:s3_129,s4:s4_130,s5:s5_131,s6:s6_134,s7:s7_135,t1:t1_188 + defs: a0:a0_178,a1:a1_179,a2:a2_180,a3:a3_181,a4:a4_182,fa3:fa3_189,fa4:fa4_186,fa5:fa5_187,gp:gp_183,ra:ra_174,s0:s0_169,s1:s1_175,s2:s2_170,s3:s3_171,s4:s4_172,s5:s5_173,s6:s6_176,s7:s7_177,t1:t1_188 + branch a0_178 == 0<64> l0000000000017E0C l0000000000017E04: - a0 = __strdup(a0) - Mem0[s3:word64] = a0 - // succ: l0000000000017E0C + Mem191[s3_171:word64] = __strdup(a0_178) l0000000000017E0C: - a5 = Mem0[gp + -1976:word64] - a0 = s1 - call a5 (retsize: 0;) - // succ: l0000000000017E18 + call Mem193[gp_183 + -1976:word64] (retsize: 0;) + uses: a0:s1_175,a1:a1_179,a2:a2_180,a3:a3_181,a4:a4_182,fa3:fa3_231,fa4:fa4_228,fa5:fa5_229,gp:gp_183,Mem:Mem193,ra:ra_174,s0:s0_169,s1:s1_175,s2:s2_170,s3:s3_171,s4:s4_172,s5:s5_173,s6:s6_176,s7:s7_177,t1:t1_230 + defs: a2:a2_222,a3:a3_223,a4:a4_224,fa3:fa3_231,fa4:fa4_228,fa5:fa5_229,gp:gp_225,ra:ra_216,s0:s0_211,s1:s1_217,s2:s2_212,s3:s3_213,s4:s4_214,s5:s5_215,s6:s6_218,s7:s7_219,t1:t1_230 l0000000000017E18: - a5 = Mem0[gp + -1952:word64] - a1 = 16 - a0 = 30 - call a5 (retsize: 0;) - s1 = a0 - branch a0 == 0<64> l0000000000017EE8 - // succ: l0000000000017E30 l0000000000017EE8 + call Mem233[gp_225 + -1952:word64] (retsize: 0;) + uses: a0:30,a1:16,a2:a2_246,a3:a3_247,a4:a4_248,fa3:fa3_271,fa4:fa4_268,fa5:fa5_269,gp:gp_232,Mem:Mem233,ra:ra_242,s0:s0_237,s1:s1_243,s2:s2_238,s3:s3_239,s4:s4_240,s5:s5_241,s6:s6_244,s7:s7_245,t1:t1_270 + defs: a0:a0_260,a2:a2_262,a3:a3_263,a4:a4_264,fa3:fa3_271,fa4:fa4_268,fa5:fa5_269,gp:gp_265,ra:ra_256,s0:s0_251,s2:s2_252,s3:s3_253,s4:s4_254,s5:s5_255,s6:s6_258,s7:s7_259,t1:t1_270 + s1_272 = a0_260 + branch a0_260 == 0<64> l0000000000017EE8 +l0000000000017EE8: + call Mem233[gp + -1952:word64] (retsize: 0;) + uses: a0:31,a1:16,a2:a2_262,a3:a3_263,a4:a4_264,fa3:fa3_297,fa4:fa4_294,fa5:fa5_295,gp:gp_265,Mem:Mem233,ra:ra_256,s0:s0_251,s1:a0_260,s2:s2_252,s3:s3_253,s4:s4_254,s5:s5_255,s6:s6_258,s7:s7_259,t1:t1_296 + defs: a0:a0_286,fa3:fa3_297,fa4:fa4_294,fa5:fa5_295,gp:gp_291,ra:ra_282,s0:s0_277,s2:s2_278,s3:s3_279,s4:s4_280,s5:s5_281,s6:s6_284,s7:s7_285,t1:t1_296 + s1_272 = a0_260 + branch a0_260 != 0<64> l0000000000017E30 +l0000000000017F00: l0000000000017E30: - a4 = CONVERT(Mem0[s0 + 4:uint32], uint32, word64) - a5 = CONVERT(Mem0[s0 + 12:uint32], uint32, word64) - a1 = CONVERT(Mem0[s0:uint32], uint32, word64) - a2 = CONVERT(Mem0[s0 + 8:uint32], uint32, word64) - a3 = Mem0[gp + -2008:word64] - a4 = a4 << 0x20 - a5 = a5 << 0x20 - a6 = 1 - Mem0[s1 + 76:word32] = SLICE(a6, word32, 0) - a1 = a4 | a1 - a2 = a5 | a2 - call a3 (retsize: 0;) - s0 = a0 - branch a0 == 0<64> l0000000000017E88 - // succ: l0000000000017E68 l0000000000017E88 + a4_301 = CONVERT(Mem233[s0_251 + 4:uint32], uint32, word64) + a5_302 = CONVERT(Mem233[s0_251 + 12:uint32], uint32, word64) + a1_303 = CONVERT(Mem233[s0_251:uint32], uint32, word64) + a2_304 = CONVERT(Mem233[s0_251 + 8:uint32], uint32, word64) + a3_306 = Mem233[gp + -2008:word64] + Mem311[s1_272 + 76:word32] = 1<32> + call a3_306 (retsize: 0;) + uses: a0:a0_321,a1:a4_301 << 0x20 | a1_303,a2:a5_302 << 0x20 | a2_304,a3:a3_306,a4:a4_301 << 0x20,a5:a5_302 << 0x20,a6:1,fa3:fa3_344,fa4:fa4_341,fa5:fa5_342,gp:gp_305,Mem:Mem311,ra:ra_318,s0:s0_299,s1:s1_310,s2:s2_314,s3:s3_315,s4:s4_316,s5:s5_317,s6:s6_319,s7:s7_320,t1:t1_343 + defs: a0:a0_333,a1:a1_334,a2:a2_335,a3:a3_336,a4:a4_337,fa3:fa3_344,fa4:fa4_341,fa5:fa5_342,gp:gp_338,s1:s1_330,s2:s2_325,s5:s5_328,sp:sp_323,t1:t1_343 + branch a0_333 == 0<64> l0000000000017E88 l0000000000017E68: - a0 = Mem0[a0 + 32:word64] - branch a0 == 0<64> l0000000000017E78 - // succ: l0000000000017E70 l0000000000017E78 + a0_346 = Mem311[a0_333 + 32:word64] + branch a0_346 == 0<64> l0000000000017E78 l0000000000017E70: - a0 = __strdup(a0) - Mem0[s2:word64] = a0 - // succ: l0000000000017E78 + Mem348[s2_325:word64] = __strdup(a0_346) l0000000000017E78: - fa4 = SEQ(0xFFFFFFFF<32>, Mem0[s0 + 52:real32]) - v24 = SLICE(0<64>, int32, 0) - fa5 = SEQ(0xFFFFFFFF<32>, v24) - a5 = CONVERT(SLICE(fa4, real32, 0) == SLICE(fa5, real32, 0), bool, word64) - branch a5 == 0<64> l0000000000017EBC - // succ: l0000000000017E88 l0000000000017EBC -l0000000000017E88: - a0 = s1 - ra = Mem0[sp + 72:word64] - s0 = Mem0[sp + 64:word64] - s1 = Mem0[sp + 56:word64] - s2 = Mem0[sp + 48:word64] - s3 = Mem0[sp + 40:word64] - s4 = Mem0[sp + 32:word64] - s5 = Mem0[sp + 24:word64] - s6 = Mem0[sp + 16:word64] - s7 = Mem0[sp + 8:word64] - t1 = Mem0[gp + -1976:word64] - sp = sp + 80 - call t1 (retsize: 0;) - return - // succ: fn0000000000017D10_exit + branch CONVERT(Mem350[a0_333 + 52:real32] == 0.0F, bool, word64) == 0<64> l0000000000017EBC l0000000000017EBC: - fa5 = SEQ(0xFFFFFFFF<32>, Mem0[s0 + 48:real32]) - fa4 = CONVERT(SLICE(fa4, real32, 0), real32, real64) - a2 = 0x13000<64> - fa5 = CONVERT(SLICE(fa5, real32, 0), real32, real64) - a4 = fa4 - a2 = a2 + -1152 - a3 = fa5 - a1 = 1 - a0 = s5 - a0 = SEQ(0<32>, __asprintf_chk(a0, SLICE(a1, int32, 0), a2, fa3, fa4)) - goto l0000000000017E88 - // succ: l0000000000017E88 -l0000000000017EE8: - a5 = Mem0[gp + -1952:word64] - a1 = 16 - a0 = 31 - call a5 (retsize: 0;) - s1 = a0 - branch a0 != 0<64> l0000000000017E30 - // succ: l0000000000017F00 l0000000000017E30 -l0000000000017F00: - goto l0000000000017D54 - // succ: l0000000000017D54 + fa4_356 = CONVERT(Mem350[a0_333 + 52:real32], real32, real64) + a3_336 = CONVERT(Mem350[a0_333 + 48:real32], real32, real64) + __asprintf_chk(s5_328, 1, 0x12B80<64>, fa3_344, fa4_356) + a4_337 = fa4_356 + a2_335 = 0x12B80<64> + a1_334 = 1 +l0000000000017E88: + call Mem372[gp_338 + -1976:word64] (retsize: 0;) + uses: a0:s1_330,a1:a1_386,a2:a2_388,a3:a3_390,a4:a4_392,fa3:fa3_415,fa4:fa4_412,fa5:fa5_413,gp:gp_338,Mem:Mem372,ra:Mem372[sp_323 + 72:word64],s0:Mem372[sp_323 + 64:word64],s1:Mem372[sp_323 + 56:word64],s2:Mem372[sp_323 + 48:word64],s3:Mem372[sp_323 + 40:word64],s4:Mem372[sp_323 + 32:word64],s5:Mem372[sp_323 + 24:word64],s6:Mem372[sp_323 + 16:word64],s7:Mem372[sp_323 + 8:word64],t1:t1_414 + defs: fa3:fa3_415,fa4:fa4_412,fa5:fa5_413,gp:gp_409,s0:s0_395,s3:s3_397,s4:s4_398,s6:s6_402,t1:t1_414 + s0Out = s0_395 + s3Out = s3_397 + s4Out = s4_398 + s6Out = s6_402 + return gp_409 +l0000000000017D54: + s0Out = s0 + s3Out = s3 + s4Out = s4 + s6Out = s6 + return gp fn0000000000017D10_exit: -// fn0000000000017F04 -// Return size: 0 -define fn0000000000017F04 +word64 fn0000000000017F04(word64 gp, word64 a0, word64 a1, word64 a2, word64 a3) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// Called from: +// fn0000000000016D74 +// MayUse: a0:[0..63] a1:[0..63] a2:[0..63] a3:[0..63] gp:[0..63] +// LiveOut: a0:[0..63]-fn0000000000016D74 +// Trashed: a0 a1 a2 a3 a4 a5 a6 t1 t3 +// Preserved: a7 ra s0 s1 s2 s3 s4 s5 s6 sp fn0000000000017F04_entry: - sp = fp - // succ: l0000000000017F04 l0000000000017F04: - sp = sp + -80 - Mem0[sp + 40:word64] = s3 - a5 = Mem0[gp + -1936:word64] - Mem0[sp + 64:word64] = s0 - Mem0[sp + 56:word64] = s1 - Mem0[sp + 48:word64] = s2 - Mem0[sp + 32:word64] = s4 - Mem0[sp + 24:word64] = s5 - Mem0[sp + 16:word64] = s6 - s0 = a1 - Mem0[sp + 72:word64] = ra - s5 = a2 - s4 = a3 - Mem0[sp + 8:word64] = a5 - Mem0[sp:word64] = 0<64> - call fn00000000000182B4 (retsize: 0;) - a1 = CONVERT(SLICE(a0, word32, 0) >>u 16, word32, int64) - t1 = CONVERT(SLICE(a0, word32, 0) >>u 8, word32, int64) - t3 = 32 - s6 = CONVERT(SLICE(a0, word32, 0) >>u 24, word32, int64) - s1 = a1 & 255 - s2 = t1 & 255 - branch s0 == t3 l0000000000018048 - // succ: l0000000000017F60 l0000000000018048 + a5_7 = Mem5[gp + -1936:word64] + Mem29[&ptrLoc50:word64] = 0<64> + a0_31 = fn00000000000182B4(a0, out a3_223, out a4_224) + a1_35 = CONVERT(SLICE(a0_31, word32, 0) >>u 16, word32, int64) + t1_36 = CONVERT(SLICE(a0_31, word32, 0) >>u 8, word32, int64) + s6_38 = CONVERT(SLICE(a0_31, word32, 0) >>u 24, word32, int64) + branch a1 == 32 l0000000000018048 +l0000000000018048: + a0_116 = CONVERT(__asprintf_chk(&ptrLoc50, 1, 0x12B88<64>, SLICE(a0_31, uint32, 0) & 0xFF, SLICE(t1_36, uint32, 0) & 0xFF, SLICE(a1_35, uint32, 0) & 0xFF, SLICE(s6_38, uint32, 0)), uint32, uint64) l0000000000017F60: - a1 = 24 - branch s0 == a1 l0000000000018070 - // succ: l0000000000017F68 l0000000000018070 + branch a1 == 24 l0000000000018070 +l0000000000018070: + a0_116 = CONVERT(__asprintf_chk(&ptrLoc50, 1, 0x12BA8<64>, SLICE(t1_36, uint32, 0) & 0xFF, SLICE(a1_35, uint32, 0) & 0xFF, SLICE(s6_38, uint32, 0)), uint32, uint64) l0000000000017F68: - a0 = 16 - branch s0 == a0 l00000000000180D8 - // succ: l0000000000017F70 l00000000000180D8 + branch a1 == 16 l00000000000180D8 +l00000000000180D8: + a0_116 = CONVERT(__asprintf_chk(&ptrLoc50, 1, 0x12BC0<64>, SLICE(a1_35, uint32, 0) & 0xFF, SLICE(s6_38, uint32, 0)), uint32, uint64) l0000000000017F70: - a5 = 8 - branch s0 == a5 l00000000000180F8 - // succ: l0000000000017F78 l00000000000180F8 + branch a1 == 8 l00000000000180F8 +l00000000000180F8: + a0_116 = CONVERT(__asprintf_chk(&ptrLoc50, 1, 0x12BD8<64>, SLICE(s6_38, uint32, 0)), uint32, uint64) l0000000000017F78: - branch a1 u 24 l0000000000017FBC +l0000000000017FBC: + a0_116 = CONVERT(__asprintf_chk(&ptrLoc50, 1, 0x12BF0<64>, SLICE(fn00000000000182B4(a2, out a3_225, out a4_226), uint32, 0) & 0xFF, SLICE(fn00000000000182B4(a3, out a3_227, out a4_228), uint32, 0) & 0xFF, SLICE(t1_36, uint32, 0) & 0xFF, SLICE(a1_35, uint32, 0) & 0xFF, SLICE(s6_38, uint32, 0)), uint32, uint64) l0000000000017F7C: - branch a0 u 16 l0000000000018094 +l0000000000018094: + a0_116 = CONVERT(__asprintf_chk(&ptrLoc50, 1, 0x12C10<64>, SLICE(fn00000000000182B4(a2, out a3_229, out a4_230), word32, 0) >>u 8 & 0xFF, SLICE(fn00000000000182B4(a3, out a3_231, out a4_232), word32, 0) >>u 8 & 0xFF, SLICE(a1_35, uint32, 0) & 0xFF, SLICE(s6_38, uint32, 0)), uint32, uint64) l0000000000017F80: - branch a5 - // succ: l0000000000017F88 -l0000000000017F88: - a4 = Mem0[sp + 8:word64] - a5 = Mem0[gp + -1936:word64] - branch a4 != a5 l0000000000018114 - // succ: l0000000000017F94 l0000000000018114 -l0000000000017F94: - ra = Mem0[sp + 72:word64] - s0 = Mem0[sp + 64:word64] - s1 = Mem0[sp + 56:word64] - s2 = Mem0[sp + 48:word64] - s3 = Mem0[sp + 40:word64] - s4 = Mem0[sp + 32:word64] - s5 = Mem0[sp + 24:word64] - s6 = Mem0[sp + 16:word64] - sp = sp + 80 - return - // succ: fn0000000000017F04_exit -l0000000000017FBC: - a0 = s5 - call fn00000000000182B4 (retsize: 0;) - s0 = a0 - a0 = s4 - call fn00000000000182B4 (retsize: 0;) - a2 = 0x13000<64> - a4 = a0 & 255 - a7 = s6 - a6 = s1 - a5 = s2 - a3 = s0 & 255 - a2 = a2 + -1040 - a1 = 1 - a0 = sp - a0 = SEQ(0<32>, __asprintf_chk(a0, SLICE(a1, int32, 0), a2, SLICE(a3, uint32, 0), SLICE(a4, uint32, 0), SLICE(a5, uint32, 0), SLICE(a6, uint32, 0), SLICE(a7, uint32, 0))) - // succ: l0000000000017FF8 + branch a1 >u 8 l0000000000018008 +l0000000000018008: + a0_116 = CONVERT(__asprintf_chk(&ptrLoc50, 1, 0x12C30<64>, SLICE(fn00000000000182B4(a2, out a3_233, out a4_234), word32, 0) >>u 16 & 0xFF, SLICE(fn00000000000182B4(a3, out a3_235, out a4_236), word32, 0) >>u 16 & 0xFF, SLICE(s6_38, uint32, 0)), uint32, uint64) l0000000000017FF8: - a5 = -1 - branch a0 == a5 l0000000000017F84 - // succ: l0000000000018000 l0000000000017F84 + branch a0_116 == -1 l0000000000017F84 l0000000000018000: - a0 = Mem0[sp:word64] - goto l0000000000017F88 - // succ: l0000000000017F88 -l0000000000018008: - a0 = s5 - call fn00000000000182B4 (retsize: 0;) - s0 = a0 - a0 = s4 - call fn00000000000182B4 (retsize: 0;) - a4 = CONVERT(SLICE(a0, word32, 0) >>u 16, word32, int64) - a3 = CONVERT(SLICE(s0, word32, 0) >>u 16, word32, int64) - a2 = 0x13000<64> - a5 = s6 - a4 = a4 & 255 - a3 = a3 & 255 - a2 = a2 + -976 - a1 = 1 - a0 = sp - a0 = SEQ(0<32>, __asprintf_chk(a0, SLICE(a1, int32, 0), a2, SLICE(a3, uint32, 0), SLICE(a4, uint32, 0), SLICE(a5, uint32, 0))) - goto l0000000000017FF8 - // succ: l0000000000017FF8 -l0000000000018048: - a2 = 0x13000<64> - a3 = a0 & 255 - a6 = s6 - a5 = s1 - a4 = s2 - a2 = a2 + -1144 - a1 = 1 - a0 = sp - a0 = SEQ(0<32>, __asprintf_chk(a0, SLICE(a1, int32, 0), a2, SLICE(a3, uint32, 0), SLICE(a4, uint32, 0), SLICE(a5, uint32, 0), SLICE(a6, uint32, 0))) - goto l0000000000017FF8 - // succ: l0000000000017FF8 -l0000000000018070: - a2 = 0x13000<64> - a5 = s6 - a4 = s1 - a3 = s2 - a2 = a2 + -1112 - a1 = 1 - a0 = sp - a0 = SEQ(0<32>, __asprintf_chk(a0, SLICE(a1, int32, 0), a2, SLICE(a3, uint32, 0), SLICE(a4, uint32, 0), SLICE(a5, uint32, 0))) - goto l0000000000017FF8 - // succ: l0000000000017FF8 -l0000000000018094: - a0 = s5 - call fn00000000000182B4 (retsize: 0;) - s0 = a0 - a0 = s4 - call fn00000000000182B4 (retsize: 0;) - a4 = CONVERT(SLICE(a0, word32, 0) >>u 8, word32, int64) - a3 = CONVERT(SLICE(s0, word32, 0) >>u 8, word32, int64) - a2 = 0x13000<64> - a6 = s6 - a5 = s1 - a4 = a4 & 255 - a3 = a3 & 255 - a2 = a2 + -1008 - a1 = 1 - a0 = sp - a0 = SEQ(0<32>, __asprintf_chk(a0, SLICE(a1, int32, 0), a2, SLICE(a3, uint32, 0), SLICE(a4, uint32, 0), SLICE(a5, uint32, 0), SLICE(a6, uint32, 0))) - goto l0000000000017FF8 - // succ: l0000000000017FF8 -l00000000000180D8: - a2 = 0x13000<64> - a4 = s6 - a3 = s1 - a2 = a2 + -1088 - a1 = 1 - a0 = sp - a0 = SEQ(0<32>, __asprintf_chk(a0, SLICE(a1, int32, 0), a2, SLICE(a3, uint32, 0), SLICE(a4, uint32, 0))) - goto l0000000000017FF8 - // succ: l0000000000017FF8 -l00000000000180F8: - a2 = 0x13000<64> - a3 = s6 - a2 = a2 + -1064 - a1 = 1 - a0 = sp - a0 = SEQ(0<32>, __asprintf_chk(a0, SLICE(a1, int32, 0), a2, SLICE(a3, uint32, 0))) - goto l0000000000017FF8 - // succ: l0000000000017FF8 + a0_142 = Mem29[&ptrLoc50:word64] +l0000000000017F84: + a0_142 = 0 +l0000000000017F88: + branch a5_7 != Mem29[gp + -1936:word64] l0000000000018114 l0000000000018114: __stack_chk_fail() +l0000000000017F94: + return a0_142 fn0000000000017F04_exit: -// fn0000000000018118 -// Return size: 0 -define fn0000000000018118 +word64 fn0000000000018118(word64 gp, word64 a0, word64 a1) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// Called from: +// fn00000000000175BC +// MayUse: a0:[0..63] a1:[0..63] gp:[0..63] +// LiveOut: a0:[0..63]-fn00000000000175BC +// Trashed: a0 a4 a5 t4 +// Preserved: a1 a2 a3 a6 a7 ra s0 sp t1 t3 t5 t6 fn0000000000018118_entry: - sp = fp - // succ: l0000000000018118 l0000000000018118: - sp = sp + -288 - Mem0[sp + 272:word64] = s0 - a5 = Mem0[gp + -1936:word64] - Mem0[sp + 280:word64] = ra - t4 = a1 & 3 - Mem0[sp + 264:word64] = a5 - branch t4 != 0<64> l00000000000182A8 - // succ: l0000000000018134 l00000000000182A8 + a5_7 = Mem5[gp + -1936:word64] + t4_11 = a1 & 3 + branch (a1 & 3) != 0<64> l00000000000182A8 +l00000000000182A8: + a0_13 = 0 l0000000000018134: - a5 = a1 & 7 - a4 = 4 - t5 = CONVERT(SLICE(a1, word32, 0) >>u 3, word32, int64) - branch a5 == a4 l0000000000018264 - // succ: l0000000000018144 l0000000000018264 + t5_16 = CONVERT(SLICE(a1, word32, 0) >>u 3, word32, int64) + branch (a1 & 7) == 4 l0000000000018264 +l0000000000018264: + a5_27 = CONVERT(Mem12[a0 + CONVERT((SLICE(a1, word32, 0) + 4<32> >>u 3) - 1, word32, word64):byte], byte, word64) + a4_30 = (a5_27 >>u 4) + 87 + branch a5_27 >>u 4 >u 9 l0000000000018294 +l0000000000018290: + a4_30 = (a5_27 >>u 4) + 48 +l0000000000018294: + Mem35[&bLoc0118:byte] = SLICE(a4_30, byte, 0) + t4_11 = 2 l0000000000018144: - branch t5 == 0<64> l00000000000181FC - // succ: l0000000000018148 l00000000000181FC + branch t5_16 == 0<64> l00000000000181FC l0000000000018148: - v12 = SLICE(t5, word32, 0) - a1 = CONVERT(v12 - 1, word32, int64) - a4 = t4 - t1 = 9 - a7 = 46 - t3 = -1 - goto l0000000000018190 - // succ: l0000000000018190 -l0000000000018160: - a2 = a2 << 0x20 - a5 = sp + 272 - a2 = a2 >>u 0x20 - a3 = a3 << 0x20 - a2 = a5 + a2 - a3 = a3 >>u 0x20 - Mem0[a2 + -264:byte] = SLICE(a6, byte, 0) - a3 = a5 + a3 - Mem0[a3 + -264:byte] = SLICE(a7, byte, 0) - v32 = SLICE(a1, word32, 0) - a1 = CONVERT(v32 - 1, word32, int64) - v33 = SLICE(a4, word32, 0) - a4 = CONVERT(v33 + 4, word32, int64) - branch a1 == t3 l00000000000181F4 - // succ: l0000000000018190 l00000000000181F4 + a1_103 = CONVERT(SLICE(t5_16, word32, 0) - 1, word32, int64) + a4_106 = t4_11 l0000000000018190: - a5 = a1 << 0x20 - a5 = a5 >>u 0x20 - a5 = a0 + a5 - a5 = CONVERT(Mem0[a5:byte], byte, word64) - v17 = SLICE(a4, word32, 0) - a3 = CONVERT(v17 + 1, word32, int64) - a2 = a5 & 15 - a6 = a2 + 87 - branch t1 , word32, int64) + a6_58 = (a5_53 & 15) + 87 + branch (a5_53 & 15) >u 9 l00000000000181B4 l00000000000181B0: - a6 = a2 + 48 - // succ: l00000000000181B4 + a6_58 = (a5_53 & 15) + 48 l00000000000181B4: - a2 = a4 << 0x20 - t6 = sp + 272 - a2 = a2 >>u 0x20 - a3 = a3 << 0x20 - a2 = t6 + a2 - a3 = a3 >>u 0x20 - Mem0[a2 + -264:byte] = SLICE(a6, byte, 0) - a3 = t6 + a3 - a5 = a5 >>u 4 - Mem0[a3 + -264:byte] = SLICE(a7, byte, 0) - v27 = SLICE(a4, word32, 0) - a2 = CONVERT(v27 + 2, word32, int64) - v28 = SLICE(a4, word32, 0) - a3 = CONVERT(v28 + 3, word32, int64) - a6 = a5 + 48 - branch t1 >=u a5 l0000000000018160 - // succ: l00000000000181EC l0000000000018160 + Mem72[fp + -16 + CONVERT(SLICE(a4_106, word32, 0), word32, word64) + -264:byte] = SLICE(a6_58, byte, 0) + Mem78[fp + -16 + CONVERT(SLICE(a3_56, word32, 0), word32, word64) + -264:byte] = 0x2E<8> + a2_80 = CONVERT(SLICE(a4_106, word32, 0) + 2, word32, int64) + a3_82 = CONVERT(SLICE(a4_106, word32, 0) + 3, word32, int64) + a6_83 = (a5_53 >>u 4) + 48 + branch a5_53 >>u 4 <=u 9 l0000000000018160 l00000000000181EC: - a6 = a5 + 87 - goto l0000000000018160 - // succ: l0000000000018160 + a6_83 = (a5_53 >>u 4) + 87 +l0000000000018160: + Mem96[fp + -16 + CONVERT(SLICE(a2_80, word32, 0), word32, word64) + -264:byte] = SLICE(a6_83, byte, 0) + Mem99[fp + -16 + CONVERT(SLICE(a3_82, word32, 0), word32, word64) + -264:byte] = 0x2E<8> + a1_103 = CONVERT(SLICE(a1_103, word32, 0) - 1, word32, int64) + a4_106 = CONVERT(SLICE(a4_106, word32, 0) + 4, word32, int64) + branch a1_103 == -1 l00000000000181F4 l00000000000181F4: - t5 = CONVERT(SLICE(t5, word32, 0) << 2<64>, word32, int64) - v34 = SLICE(t4, word32, 0) - v35 = SLICE(t5, word32, 0) - t4 = CONVERT(v34 + v35, word32, int64) - // succ: l00000000000181FC + t4_11 = CONVERT(SLICE(t4_11, word32, 0) + (SLICE(t5_16, word32, 0) << 2<64>), word32, int64) l00000000000181FC: - t4 = t4 << 0x20 - a5 = 0x7000<64> - a4 = sp + 8 - t4 = t4 >>u 0x20 - t4 = a4 + t4 - v21 = SLICE(a5, word32, 0) - a4 = CONVERT(v21 + 105, word32, int64) - v22 = SLICE(a5, word32, 0) - a5 = CONVERT(v22 + 609, word32, int64) - Mem0[t4 + 4:word16] = SLICE(a5, word16, 0) - a5 = 0x6000<64> - v23 = SLICE(a5, word32, 0) - a5 = CONVERT(v23 + 368, word32, int64) - Mem0[t4:word16] = SLICE(a4, word16, 0) - a4 = 0x3000<64> - v24 = SLICE(a4, word32, 0) - a4 = CONVERT(v24 - 458, word32, int64) - Mem0[t4 + 6:word16] = SLICE(a5, word16, 0) - a5 = 46 - a0 = sp + 8 - Mem0[t4 + 2:word16] = SLICE(a4, word16, 0) - Mem0[t4 + 8:word16] = SLICE(a5, word16, 0) - a0 = __strdup(a0) - // succ: l0000000000018248 + t4_127 = &bLoc0118 + CONVERT(SLICE(t4_11, word32, 0), word32, word64) + Mem132[t4_127 + 4:word16] = 0x7261<16> + Mem136[t4_127:word16] = 0x7069<16> + Mem140[t4_127 + 6:word16] = 0x6170<16> + Mem143[t4_127 + 2:word16] = 0x2E36<16> + Mem144[t4_127 + 8:word16] = 0x2E<16> + a0_13 = __strdup(&bLoc0118) l0000000000018248: - a4 = Mem0[sp + 264:word64] - a5 = Mem0[gp + -1936:word64] - branch a4 != a5 l00000000000182B0 - // succ: l0000000000018254 l00000000000182B0 -l0000000000018254: - ra = Mem0[sp + 280:word64] - s0 = Mem0[sp + 272:word64] - sp = sp + 288 - return - // succ: fn0000000000018118_exit -l0000000000018264: - v29 = SLICE(a1, word32, 0) - v30 = SLICE(a4, word32, 0) - a5 = CONVERT(v29 + v30, word32, int64) - a5 = CONVERT(SLICE(a5, word32, 0) >>u 3, word32, int64) - v31 = SLICE(a5, word32, 0) - a5 = CONVERT(v31 - 1, word32, int64) - a5 = a5 << 0x20 - a5 = a5 >>u 0x20 - a5 = a0 + a5 - a5 = CONVERT(Mem0[a5:byte], byte, word64) - a3 = 9 - a5 = a5 >>u 4 - a4 = a5 + 87 - branch a3 - // succ: l0000000000018294 -l0000000000018294: - a5 = 46 - Mem0[sp + 8:byte] = SLICE(a4, byte, 0) - Mem0[sp + 9:byte] = SLICE(a5, byte, 0) - t4 = 2 - goto l0000000000018144 - // succ: l0000000000018144 -l00000000000182A8: - a0 = 0 - goto l0000000000018248 - // succ: l0000000000018248 + branch a5_7 != Mem147[gp + -1936:word64] l00000000000182B0 l00000000000182B0: __stack_chk_fail() +l0000000000018254: + return a0_13 fn0000000000018118_exit: -// fn00000000000182B4 -// Return size: 0 -define fn00000000000182B4 +word64 fn00000000000182B4(word64 a0, ptr64 & a3Out, ptr64 & a4Out) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// Called from: +// fn00000000000166F4 +// fn0000000000016830 +// fn0000000000016B68 +// fn0000000000016D74 +// fn0000000000017B40 +// fn0000000000017F04 +// MayUse: a0:[0..31] +// LiveOut: a0:[0..63]-fn00000000000166F4 a3:[0..63]-fn0000000000017B40 a4:[0..63]-fn0000000000017B40 +// Trashed: a0 a3 a4 a5 +// Preserved: sp fn00000000000182B4_entry: - sp = fp - // succ: l00000000000182B4 l00000000000182B4: - a5 = CONVERT(SLICE(a0, word32, 0) << 0x18<64>, word32, int64) - a3 = CONVERT(SLICE(a0, word32, 0) >>u 24, word32, int64) - a3 = a3 | a5 - a4 = 0xFF0000<64> - a5 = 0x10000<64> - a4 = a0 & a4 - v8 = SLICE(a5, word32, 0) - a5 = CONVERT(v8 - 256, word32, int64) - a4 = CONVERT(SLICE(a4, word32, 0) >> 8, word32, int64) - a0 = a0 & a5 - a0 = CONVERT(SLICE(a0, word32, 0) << 8<64>, word32, int64) - a5 = a3 | a4 - a0 = a5 | a0 - return - // succ: fn00000000000182B4_exit + a3_6 = CONVERT(SLICE(a0, word32, 0) >>u 24, word32, int64) | CONVERT(SLICE(a0, word32, 0) << 0x18<64>, word32, int64) + a3Out = a3_6 + a4_12 = CONVERT((SLICE(a0, word32, 0) & 0xFF0000<32>) >> 8, word32, int64) + a4Out = a4_12 + return a3_6 | a4_12 | CONVERT((SLICE(a0, word32, 0) & 0xFF00<32>) << 8<64>, word32, int64) fn00000000000182B4_exit: -// fn00000000000182E8 -// Return size: 0 -define fn00000000000182E8 +void fn00000000000182E8(word64 ra, word64 a0, word64 a1, word64 a2) +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// MayUse: a0:[0..63] a1:[0..63] a2:[0..63] ra:[0..63] +// LiveOut: +// Trashed: a0 a1 a2 a5 +// Preserved: ra s0 s1 s2 s3 s4 s5 sp fn00000000000182E8_entry: - sp = fp - // succ: l00000000000182E8 l00000000000182E8: - sp = sp + -64 - Mem0[sp + 48:word64] = s0 - Mem0[sp + 32:word64] = s2 - s0 = 0x000000000001A2F4 - s0 = s0 + -1244 - s2 = 0x000000000001A2FC - s2 = s2 + -1244 - s2 = s2 - s0 - Mem0[sp + 56:word64] = ra - Mem0[sp + 40:word64] = s1 - Mem0[sp + 24:word64] = s3 - Mem0[sp + 16:word64] = s4 - Mem0[sp + 8:word64] = s5 - s2 = s2 >> 3 - branch s2 == 0<64> l0000000000018354 - // succ: l0000000000018324 l0000000000018354 + s2_12 = 0x0000000000019E20 - 0x0000000000019E18 + s0_31 = 0x0000000000019E18 + s2_23 = s2_12 >> 3 + branch s2_12 >> 3 == 0<64> l0000000000018354 l0000000000018324: - s5 = a0 - s4 = a1 - s3 = a2 - s1 = 0 - // succ: l0000000000018334 + s5_25 = a0 + s4_27 = a1 + s3_29 = a2 + s1_30 = 0 l0000000000018334: - a5 = Mem0[s0:word64] - a2 = s3 - a1 = s4 - a0 = s5 - s1 = s1 + 1 - call a5 (retsize: 0;) - s0 = s0 + 8 - branch s2 != s1 l0000000000018334 - // succ: l0000000000018354 l0000000000018334 + call Mem22[s0_31:word64] (retsize: 0;) + uses: a0:s5_38,a1:s4_36,a2:s3_34,a5:a5_56,Mem:Mem22,ra:ra_43,s0:s0_31,s1:s1_40 + 1,s2:s2_42,s3:s3_34,s4:s4_36,s5:s5_38 + defs: a5:a5_56,ra:ra_48,s0:s0_46,s1:s1_49,s2:s2_47,s3:s3_50,s4:s4_51,s5:s5_52 + s0_31 = s0_46 + 8 + branch s2_23 != s1_30 l0000000000018334 l0000000000018354: - ra = Mem0[sp + 56:word64] - s0 = Mem0[sp + 48:word64] - s1 = Mem0[sp + 40:word64] - s2 = Mem0[sp + 32:word64] - s3 = Mem0[sp + 24:word64] - s4 = Mem0[sp + 16:word64] - s5 = Mem0[sp + 8:word64] - sp = sp + 64 return - // succ: fn00000000000182E8_exit fn00000000000182E8_exit: -// fn0000000000018378 -// Return size: 0 -define fn0000000000018378 +void fn0000000000018378() +// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1 + +// MayUse: +// LiveOut: +// Trashed: +// Preserved: sp fn0000000000018378_entry: - sp = fp - // succ: l0000000000018378 l0000000000018378: return - // succ: fn0000000000018378_exit fn0000000000018378_exit: diff --git a/subjects/Elf/nanoMips/ping/ping.reko/ping_text_0000.asm b/subjects/Elf/nanoMips/ping/ping.reko/ping_text_0000.asm index b0cb448f57..a5d7d209cd 100644 --- a/subjects/Elf/nanoMips/ping/ping.reko/ping_text_0000.asm +++ b/subjects/Elf/nanoMips/ping/ping.reko/ping_text_0000.asm @@ -5,18 +5,18 @@ ;; 004018A2 (in ping4_receive_error_msg) ;; 00401AB4 (in ping4_parse_reply) acknowledge proc - lwpc r7,004544E4 + lwpc r7,ntransmitted subu r5,r7,r4 andi r6,r5,0000FFFF bbnezc r5,0000000F,00400136 l004000FE: - lwpc r5,00430078 + lwpc r5,pipesize bltc r6,r5,00400110 l00400108: addiu r6,r6,00000001 - swpc r6,00430078 + swpc r6,pipesize l00400110: aluipc r6,00000454 @@ -47,7 +47,7 @@ set_socket_option.isra.0.part.1 proc balc strerror addiupc r5,00010384 move r6,r4 - lwpc r4,00412EF0 + lwpc r4,stderr balc fprintf li r4,00000002 balc exit @@ -135,7 +135,7 @@ l004001D8: beqzc r7,004001F0 l004001DC: - lwpc r5,00412EF0 + lwpc r5,stderr addiupc r4,000106DE balc fputs_unlocked @@ -170,7 +170,7 @@ l00400280: 004002A0 E0 80 C0 E4 96 9B CB 60 3C 42 05 00 A1 04 A4 06 .......`