From 5fab3a419c0e5583b5ca76bd24e414d8453da3b3 Mon Sep 17 00:00:00 2001 From: x86byte <111459558+x86byte@users.noreply.github.com> Date: Mon, 29 Jun 2026 11:48:20 +0100 Subject: [PATCH] cfgrip: standalone CFG extraction tool from PE/ELF binaries --- .gitignore | 1 + CMakeLists.txt | 31 + CODE_OF_CONDUCT.md | 14 + CONTRIBUTING.md | 39 + LICENSE | 21 + README.md | 419 + SECURITY.md | 7 + cfg/builder.cpp | 530 + cfg/builder.hpp | 35 + disasm/engine.cpp | 163 + disasm/engine.hpp | 28 + loader/binary.cpp | 15 + loader/binary.hpp | 39 + loader/elf.cpp | 332 + loader/elf.hpp | 52 + loader/pe.cpp | 276 + loader/pe.hpp | 37 + main.cpp | 74 + tests/example1.exe | Bin 0 -> 210944 bytes tests/example1.exe.cfg | 151183 ++++++++++++++++++++++++++++++++++++++ types.hpp | 169 + 21 files changed, 153465 insertions(+) create mode 100644 .gitignore create mode 100644 CMakeLists.txt create mode 100644 CODE_OF_CONDUCT.md create mode 100644 CONTRIBUTING.md create mode 100644 LICENSE create mode 100644 README.md create mode 100644 SECURITY.md create mode 100644 cfg/builder.cpp create mode 100644 cfg/builder.hpp create mode 100644 disasm/engine.cpp create mode 100644 disasm/engine.hpp create mode 100644 loader/binary.cpp create mode 100644 loader/binary.hpp create mode 100644 loader/elf.cpp create mode 100644 loader/elf.hpp create mode 100644 loader/pe.cpp create mode 100644 loader/pe.hpp create mode 100644 main.cpp create mode 100644 tests/example1.exe create mode 100644 tests/example1.exe.cfg create mode 100644 types.hpp diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..567609b --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +build/ diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..8237663 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,31 @@ +cmake_minimum_required(VERSION 3.14) +project(cfgrip) + +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +include(FetchContent) +FetchContent_Declare( + capstone + GIT_REPOSITORY https://github.com/capstone-engine/capstone.git + GIT_TAG 5.0.7 +) +set(CAPSTONE_BUILD_TESTS OFF) +set(CAPSTONE_BUILD_SHARED OFF) +set(CAPSTONE_BUILD_CSTOOL OFF) +set(CAPSTONE_BUILD_CSVIEW OFF) +FetchContent_MakeAvailable(capstone) + +add_executable(cfgrip + main.cpp + loader/binary.cpp + loader/pe.cpp + loader/elf.cpp + disasm/engine.cpp + cfg/builder.cpp +) + +target_include_directories(cfgrip PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}) +target_include_directories(cfgrip PRIVATE ${capstone_SOURCE_DIR}/include) + +target_link_libraries(cfgrip capstone_static) diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..510a587 --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,14 @@ +# code of conduct + +## the rule + +Don't be an asshole. + +## what that means + +- No personal attacks, no harassment, no discrimination. +- Assume good faith. People make mistakes, including you. +- If someone asks you to stop, stop. +- If you see shitty behavior, call it out. + +That's it. No long document. Just don't be an asshole. diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..4505756 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,39 @@ +# contributing + +Pull requests are welcome. If you're planning something big, open an issue first so we don't step on each other. + +## building + +```sh +cmake -B build +cmake --build build --config Release +``` + +Capstone is fetched automatically via FetchContent. You don't need to install it. + +## what needs work + +- **More architectures** — right now it's x86/x86-64 only. ARM, AArch64, etc would be nice. +- **Better indirect call resolution** — the register tracer is basic. It could be smarter. +- **More binary formats** — Mach-O isn't supported yet. + +## style + +- No tabs. 4 spaces. +- No comments unless the code is genuinely confusing. +- Match the existing style. If you're changing something, make it look like it belongs. +- Keep it simple. This is not a framework. + +## committing + +Write short commit messages. Use `git rebase` to keep the history clean. No merge commits. + +## testing + +There's a test binary in `tests/`. Run cfgrip on it and make sure the output is valid JSON: + +```sh +./build/cfgrip tests/example1.exe +``` + +If your change affects the output format, update `tests/example1.exe.cfg` too. diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..7f296ae --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 BinaryHardening + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..eff6c29 --- /dev/null +++ b/README.md @@ -0,0 +1,419 @@ +# cfgrip + +PE/ELF x86/x64 CFG extractor. Takes a binary in, disassembles it, resolves every jump and call (GOT, jump tables, register tracing), and exports the full control flow graph as structured JSON. + +## why + +You need to know exactly where every branch goes. Not for reading — for patching. Feed the JSON into Zydis or AsmJit, locate the exact instruction you need to hook or modify, and write back. Anti-cheat teams use it to map out game binaries. RE people use it to lift code into their own analysis pipelines. Software analysts trace execution paths without running the binary. + +cfgrip gives you the map. What you do with it is up to you. + +## what it extracts + +For every binary cfgrip processes, it produces: + +- **Function list** with addresses and names (entry point, exports, discovered via `call` instructions) +- **Basic blocks** per function — instruction sequences terminated by branches, calls, returns, or traps +- **Control flow edges** — successors of each block (direct branches, fall-through, indirect targets) +- **Import table** — resolved library imports with addresses +- **Indirect targets** — GOT-resolved calls, jump table entries, register-traced branches, and unresolved ones (marked as such) + +It handles indirect branches by: +1. Checking the **GOT** (Global Offset Table) for known imports +2. Scanning backward for **LEA instructions** to locate jump tables, then reading table entries +3. **Tracing registers** backward through `mov`/`lea` chains to find concrete addresses + +## usage + +``` +cfgrip +``` + +That's it. Feed it a binary, get `.cfg` as output. + +--- +Example: +``` +cfgrip.exe tests\example1.exe +format: PE +arch: x86-64 +entry: 0x1400054bc +imports: 85 + 0x140020000 EncodePointer (KERNEL32.dll) + 0x140020008 DecodePointer (KERNEL32.dll) + 0x140020010 EnterCriticalSection (KERNEL32.dll) + 0x140020018 LeaveCriticalSection (KERNEL32.dll) + 0x140020020 InitializeCriticalSectionEx (KERNEL32.dll) + 0x140020028 DeleteCriticalSection (KERNEL32.dll) + 0x140020030 MultiByteToWideChar (KERNEL32.dll) + 0x140020038 WideCharToMultiByte (KERNEL32.dll) + 0x140020040 LCMapStringEx (KERNEL32.dll) + 0x140020048 GetStringTypeW (KERNEL32.dll) + 0x140020050 GetCPInfo (KERNEL32.dll) + 0x140020058 RtlCaptureContext (KERNEL32.dll) + 0x140020060 RtlLookupFunctionEntry (KERNEL32.dll) + 0x140020068 RtlVirtualUnwind (KERNEL32.dll) + 0x140020070 UnhandledExceptionFilter (KERNEL32.dll) + 0x140020078 SetUnhandledExceptionFilter (KERNEL32.dll) + 0x140020080 GetCurrentProcess (KERNEL32.dll) + 0x140020088 TerminateProcess (KERNEL32.dll) + 0x140020090 IsProcessorFeaturePresent (KERNEL32.dll) + 0x140020098 QueryPerformanceCounter (KERNEL32.dll) + 0x1400200a0 GetCurrentProcessId (KERNEL32.dll) + 0x1400200a8 GetCurrentThreadId (KERNEL32.dll) + 0x1400200b0 GetSystemTimeAsFileTime (KERNEL32.dll) + 0x1400200b8 InitializeSListHead (KERNEL32.dll) + 0x1400200c0 IsDebuggerPresent (KERNEL32.dll) + 0x1400200c8 GetStartupInfoW (KERNEL32.dll) + 0x1400200d0 GetModuleHandleW (KERNEL32.dll) + 0x1400200d8 WriteConsoleW (KERNEL32.dll) + 0x1400200e0 RtlPcToFileHeader (KERNEL32.dll) + 0x1400200e8 RaiseException (KERNEL32.dll) + 0x1400200f0 RtlUnwindEx (KERNEL32.dll) + 0x1400200f8 GetLastError (KERNEL32.dll) + 0x140020100 SetLastError (KERNEL32.dll) + 0x140020108 InitializeCriticalSectionAndSpinCount (KERNEL32.dll) + 0x140020110 TlsAlloc (KERNEL32.dll) + 0x140020118 TlsGetValue (KERNEL32.dll) + 0x140020120 TlsSetValue (KERNEL32.dll) + 0x140020128 TlsFree (KERNEL32.dll) + 0x140020130 FreeLibrary (KERNEL32.dll) + 0x140020138 GetProcAddress (KERNEL32.dll) + 0x140020140 LoadLibraryExW (KERNEL32.dll) + 0x140020148 GetStdHandle (KERNEL32.dll) + 0x140020150 WriteFile (KERNEL32.dll) + 0x140020158 GetModuleFileNameW (KERNEL32.dll) + 0x140020160 ExitProcess (KERNEL32.dll) + 0x140020168 GetModuleHandleExW (KERNEL32.dll) + 0x140020170 GetCommandLineA (KERNEL32.dll) + 0x140020178 GetCommandLineW (KERNEL32.dll) + 0x140020180 HeapAlloc (KERNEL32.dll) + 0x140020188 HeapFree (KERNEL32.dll) + 0x140020190 FlsAlloc (KERNEL32.dll) + 0x140020198 FlsGetValue (KERNEL32.dll) + 0x1400201a0 FlsSetValue (KERNEL32.dll) + 0x1400201a8 FlsFree (KERNEL32.dll) + 0x1400201b0 VirtualProtect (KERNEL32.dll) + 0x1400201b8 CompareStringW (KERNEL32.dll) + 0x1400201c0 LCMapStringW (KERNEL32.dll) + 0x1400201c8 GetLocaleInfoW (KERNEL32.dll) + 0x1400201d0 IsValidLocale (KERNEL32.dll) + 0x1400201d8 GetUserDefaultLCID (KERNEL32.dll) + 0x1400201e0 EnumSystemLocalesW (KERNEL32.dll) + 0x1400201e8 GetFileType (KERNEL32.dll) + 0x1400201f0 CloseHandle (KERNEL32.dll) + 0x1400201f8 FlushFileBuffers (KERNEL32.dll) + 0x140020200 GetConsoleOutputCP (KERNEL32.dll) + 0x140020208 GetConsoleMode (KERNEL32.dll) + 0x140020210 ReadFile (KERNEL32.dll) + 0x140020218 GetFileSizeEx (KERNEL32.dll) + 0x140020220 SetFilePointerEx (KERNEL32.dll) + 0x140020228 ReadConsoleW (KERNEL32.dll) + 0x140020230 HeapReAlloc (KERNEL32.dll) + 0x140020238 FindClose (KERNEL32.dll) + 0x140020240 FindFirstFileExW (KERNEL32.dll) + 0x140020248 FindNextFileW (KERNEL32.dll) + 0x140020250 IsValidCodePage (KERNEL32.dll) + 0x140020258 GetACP (KERNEL32.dll) + 0x140020260 GetOEMCP (KERNEL32.dll) + 0x140020268 GetEnvironmentStringsW (KERNEL32.dll) + 0x140020270 FreeEnvironmentStringsW (KERNEL32.dll) + 0x140020278 SetEnvironmentVariableW (KERNEL32.dll) + 0x140020280 SetStdHandle (KERNEL32.dll) + 0x140020288 GetProcessHeap (KERNEL32.dll) + 0x140020290 HeapSize (KERNEL32.dll) + 0x140020298 CreateFileW (KERNEL32.dll) + 0x1400202a0 RtlUnwind (KERNEL32.dll) +functions: 422 +indirect targets: 1372 +cfg written to: tests\example1.exe.cfg +``` +--- + +## the output format + +The `.cfg` file is structured JSON. Here's what it looks like: +``` +{ + "binary": "tests\\example1.exe", + "arch": "x86-64", + "format": "PE", + "entry_point": "0x1400054bc", + "imports": [ + { + "address": "0x140020000", + "name": "EncodePointer", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020008", + "name": "DecodePointer", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020010", + "name": "EnterCriticalSection", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020018", + "name": "LeaveCriticalSection", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020020", + "name": "InitializeCriticalSectionEx", + "library": "KERNEL32.dll" + }, + ... + ... + ... + "functions": [ + { + "address": "0x1400054bc", + "name": "entry", + "blocks": [ + { + "address": "0x1400054bc", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400054bc", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400054c0", + "size": 5, + "mnemonic": "call", + "operands": "0x140005d30" + }, + { + "address": "0x1400054c5", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400054c9", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140005340" + } + ], + "successors": [ + "0x140005340" + ] + }, + { + "address": "0x140005340", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005340", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140005345", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rsi" + }, + { + "address": "0x14000534a", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000534b", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000534f", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 1" + }, + { + "address": "0x140005354", + "size": 5, + "mnemonic": "call", + "operands": "0x14000550c" + }, + { + "address": "0x140005359", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x14000535b", + "size": 6, + "mnemonic": "je", + "operands": "0x140005497" + } + ], + "successors": [ + "0x140005497", + "0x140005361" + ] + }, + { + "address": "0x140005497", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005497", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 7" + }, + { + "address": "0x14000549c", + "size": 5, + "mnemonic": "call", + "operands": "0x140005e44" + }, + { + "address": "0x1400054a1", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x1400054a2", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 7" + }, + { + "address": "0x1400054a7", + "size": 5, + "mnemonic": "call", + "operands": "0x140005e44" + }, + { + "address": "0x1400054ac", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x1400054ae", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ec14" + }, + { + "address": "0x1400054b3", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x1400054b4", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x1400054b6", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ebcc" + }, + { + "address": "0x1400054bb", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x1400054bc", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400054c0", + "size": 5, + "mnemonic": "call", + "operands": "0x140005d30" + }, + { + "address": "0x1400054c5", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400054c9", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140005340" + } + ], + "successors": [ + "0x140005340" + ] + }, + ... + ... + ... +``` + +## building + +Requires CMake and a C++17 compiler. Capstone is fetched automatically. + +``` +cmake -B build +cmake --build build --config Release +./build/cfgrip +``` + +Or on Windows with Visual Studio: + +``` +cmake -B build -S . +cmake --build build --config Release +.\build\Release\cfgrip.exe +``` + +--- + +image + +image + +--- + +## what it supports + +| | | | +|---|---|:-:| +| **Formats** | PE (32/64-bit) | YES | +| | ELF (64-bit) | YES | +| **Architectures** | x86 | YES | +| | x86-64 | YES | +| **Indirect calls** | GOT resolution | YES | +| | Jump table detection | YES | +| | Backward register tracing | YES | +| **Function discovery** | Entry point | YES | +| | Exports | YES | +| | `call` targets | YES | +| | Prolog scanning (`push rbp`, CET `endbr64`) | YES | + + diff --git a/SECURITY.md b/SECURITY.md new file mode 100644 index 0000000..c7bb8d6 --- /dev/null +++ b/SECURITY.md @@ -0,0 +1,7 @@ +# security + +This tool parses untrusted binaries. There's always a risk of bugs in the parsers (PE, ELF) or the disassembler that could crash or do worse. + +If you find something, don't open a public issue. Email me directly or reach out on the repo's security tab. + +If you're integrating cfgrip into something that processes untrusted files, consider sandboxing it. diff --git a/cfg/builder.cpp b/cfg/builder.cpp new file mode 100644 index 0000000..dd05f16 --- /dev/null +++ b/cfg/builder.cpp @@ -0,0 +1,530 @@ +#include "cfg/builder.hpp" +#include +#include + +static bool isMemOp(const string& op) +{ + return op.find('[') != string::npos || op.find('+') != string::npos; +} + +static bool regMatch(const string& op, const string& target) +{ + auto norm = [](const string& s) -> string { + if (s.size() >= 3 && s[0] == 'r' && isdigit(s[1])) return s.substr(1); + if (s.size() >= 3 && s[0] == 'e' && isdigit(s[1])) return s.substr(1); + return s; + }; + return norm(op) == norm(target) || op == target; +} + +CFGBuilder::CFGBuilder(Binary* binary, Disassembler* disasm) + : m_bin(binary), m_dis(disasm) {} + +bool CFGBuilder::isVisited(addr_t addr) +{ + return m_blocks.count(addr) > 0; +} + +void CFGBuilder::markVisited(addr_t addr) +{ + m_blocks.insert(addr); +} + +void CFGBuilder::buildGotMap() +{ + auto imports = m_bin->getImportedFunctions(); + for (const auto& imp : imports) + { + if (imp.address) + m_got[imp.address] = {imp.name, imp.library}; + } +} + +addr_t CFGBuilder::resolveGOT(const Instruction& inst) +{ + if (!m_dis->isIndirectBranch(inst)) return 0; + int64_t disp = m_dis->getRIPDisp(inst); + if (disp == 0) return 0; + + addr_t got = inst.address + inst.size + disp; + auto it = m_got.find(got); + if (it != m_got.end()) + { + if (!it->second.first.empty()) return got; + } + + auto bytes = m_bin->readBytes(got, 8); + if (bytes.size() < 4) return 0; + + uint64_t target = 0; + if (bytes.size() >= 8) + { + target = bytes[0] | ((uint64_t)bytes[1] << 8) | ((uint64_t)bytes[2] << 16) | + ((uint64_t)bytes[3] << 24) | ((uint64_t)bytes[4] << 32) | + ((uint64_t)bytes[5] << 40) | ((uint64_t)bytes[6] << 48) | + ((uint64_t)bytes[7] << 56); + } + else + { + target = bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24); + } + + return target; +} + +addr_t CFGBuilder::resolveJumpTable(const vector& block, const Instruction& inst) +{ + size_t n = block.size(); + if (n < 3) return 0; + + int idx = -1; + for (int i = (int)n - 1; i >= 0; i--) + { + if (block[i].address == inst.address) { idx = i; break; } + } + if (idx < 2) return 0; + + for (int i = idx - 1; i >= max(0, idx - 8); i--) + { + if (block[i].mnemonic == "lea") + { + int64_t disp = m_dis->getRIPDisp(block[i]); + if (disp == 0) continue; + addr_t table = block[i].address + block[i].size + disp; + + int64_t bound = -1; + for (int j = i - 1; j >= max(0, i - 4); j--) + { + if (block[j].mnemonic == "cmp") + { + size_t pos = block[j].operands.find("0x"); + if (pos != string::npos) + { + try { bound = stoll(block[j].operands.substr(pos), nullptr, 16); } + catch (...) {} + } + break; + } + } + if (bound <= 0) bound = 32; + + for (int64_t e = 0; e < bound && e < 256; e++) + { + auto ent = m_bin->readBytes(table + e * 8, 8); + if (ent.size() < 4) break; + uint64_t entry = 0; + if (ent.size() >= 8) + entry = ent[0] | ((uint64_t)ent[1] << 8) | ((uint64_t)ent[2] << 16) | + ((uint64_t)ent[3] << 24) | ((uint64_t)ent[4] << 32) | + ((uint64_t)ent[5] << 40) | ((uint64_t)ent[6] << 48) | ((uint64_t)ent[7] << 56); + else + entry = ent[0] | (ent[1] << 8) | (ent[2] << 16) | (ent[3] << 24); + + if (entry == 0 || entry > 0x100000000ULL) break; + auto ranges = m_bin->getExecutableRanges(); + bool ok = false; + for (const auto& r : ranges) + if (entry >= r.first && entry < r.second) { ok = true; break; } + if (ok) return table; + else break; + } + } + } + return 0; +} + +addr_t CFGBuilder::traceReg(const string& reg, const vector& block, size_t idx) +{ + if (idx >= block.size() || idx == 0) return 0; + string cur = reg; + + for (int i = (int)idx - 1; i >= 0; i--) + { + const auto& inst = block[i]; + if (inst.mnemonic == "nop" || inst.mnemonic == "cmp" || inst.mnemonic == "test") + continue; + + size_t comma = inst.operands.find(','); + string dst = comma != string::npos ? inst.operands.substr(0, comma) : inst.operands; + while (!dst.empty() && dst[0] == ' ') dst = dst.substr(1); + while (!dst.empty() && dst.back() == ' ') dst.pop_back(); + + if (inst.mnemonic == "mov" || inst.mnemonic == "lea") + { + if (dst == cur || dst == "r" + cur.substr(1) || regMatch(dst, cur)) + { + if (inst.mnemonic == "mov" && !inst.operands.empty()) + { + size_t pos = inst.operands.rfind("0x"); + if (pos != string::npos) + { + try { return stoull(inst.operands.substr(pos), nullptr, 16); } + catch (...) {} + } + } + if (inst.mnemonic == "lea") + { + int64_t disp = m_dis->getRIPDisp(inst); + if (disp != 0) return inst.address + inst.size + disp; + } + if (comma != string::npos) + { + string src = inst.operands.substr(comma + 1); + while (!src.empty() && src[0] == ' ') src = src.substr(1); + while (!src.empty() && src.back() == ' ') src.pop_back(); + if (!src.empty() && src[0] != '0' && !isMemOp(src)) + { + cur = src; + continue; + } + } + return 0; + } + } + if (dst == cur || regMatch(dst, cur)) return 0; + } + return 0; +} + +void CFGBuilder::recordIndirect(const Instruction& inst, addr_t target, bool ok, const string& name, const string& lib) +{ + IndirectTarget it; + it.instruction_addr = inst.address; + it.resolved_target = ok ? target : 0; + it.resolved = ok; + it.name = name; + it.library = lib; + m_targets.push_back(it); +} + +BasicBlock CFGBuilder::disassembleBlock(addr_t start, addr_t& next) +{ + BasicBlock block; + block.address = start; + block.is_prolog = false; + block.is_epilog = false; + + addr_t cur = start; + auto ranges = m_bin->getExecutableRanges(); + + auto inExec = [&](addr_t a) -> bool { + for (const auto& r : ranges) + if (a >= r.first && a < r.second) return true; + return false; + }; + + for (size_t i = 0; i < 5000; ++i) + { + if (!inExec(cur)) { next = 0; break; } + + auto bytes = m_bin->readBytes(cur, 15); + if (bytes.empty()) { next = 0; break; } + + auto insts = m_dis->disassemble(bytes, cur, 1); + if (insts.empty()) { next = 0; break; } + + auto& inst = insts[0]; + block.instructions.push_back(inst); + + if (i <= 3 && !block.is_prolog && m_dis->isProlog(block.instructions)) + block.is_prolog = true; + + if (m_dis->isEpilog(inst)) + block.is_epilog = true; + + if (m_dis->isReturn(inst)) { next = 0; break; } + if (m_dis->isTrap(inst)) { next = 0; break; } + + if (m_dis->isUnconditionalBranch(inst)) + { + addr_t t = m_dis->getBranchTarget(inst); + if (t && !m_dis->isIndirectBranch(inst)) + block.successors.push_back(t); + else if (m_dis->isIndirectBranch(inst)) + { + addr_t resolved = resolveGOT(inst); + if (!resolved) + { + resolved = resolveJumpTable(block.instructions, inst); + if (resolved) + { + for (int j = (int)block.instructions.size() - 2; j >= 0; j--) + { + if (block.instructions[j].mnemonic == "lea") + { + int64_t ld = m_dis->getRIPDisp(block.instructions[j]); + if (ld != 0) + { + addr_t tbl = block.instructions[j].address + block.instructions[j].size + ld; + for (int64_t e = 0; e < 64; e++) + { + auto eb = m_bin->readBytes(tbl + e * 8, 8); + if (eb.size() < 4) break; + uint64_t entry = 0; + if (eb.size() >= 8) + entry = eb[0] | ((uint64_t)eb[1] << 8) | ((uint64_t)eb[2] << 16) | + ((uint64_t)eb[3] << 24) | ((uint64_t)eb[4] << 32) | + ((uint64_t)eb[5] << 40) | ((uint64_t)eb[6] << 48) | ((uint64_t)eb[7] << 56); + else + entry = eb[0] | (eb[1] << 8) | (eb[2] << 16) | (eb[3] << 24); + if (entry == 0 || entry > 0x100000000ULL) break; + bool ok = false; + for (const auto& r : ranges) + if (entry >= r.first && entry < r.second) { ok = true; break; } + if (ok) block.successors.push_back(entry); + else break; + } + resolved = tbl; + break; + } + } + } + } + } + if (!resolved) + { + string reg = inst.operands; + while (!reg.empty() && reg[0] == ' ') reg = reg.substr(1); + resolved = traceReg(reg, block.instructions, block.instructions.size() - 1); + if (resolved) + { + block.successors.push_back(resolved); + recordIndirect(inst, resolved, true, "traced", ""); + } + else + { + recordIndirect(inst, 0, false, "unresolved", ""); + } + } + else + { + auto git = m_got.find(resolved); + string nm = git != m_got.end() ? git->second.first : ""; + string lb = git != m_got.end() ? git->second.second : ""; + block.successors.push_back(resolved); + recordIndirect(inst, resolved, true, nm, lb); + } + } + next = 0; break; + } + + if (m_dis->isConditionalBranch(inst)) + { + addr_t t = m_dis->getBranchTarget(inst); + if (t && !m_dis->isIndirectBranch(inst)) + block.successors.push_back(t); + block.successors.push_back(cur + inst.size); + next = cur + inst.size; break; + } + + if (m_dis->isCall(inst)) + { + addr_t t = m_dis->getBranchTarget(inst); + if (t && !m_dis->isIndirectBranch(inst)) + { + m_funcs.insert(t); + recordIndirect(inst, t, true, "", ""); + } + else if (m_dis->isIndirectBranch(inst)) + { + addr_t resolved = resolveGOT(inst); + if (resolved) + { + auto git = m_got.find(resolved); + string nm = git != m_got.end() ? git->second.first : ""; + string lb = git != m_got.end() ? git->second.second : ""; + auto gb = m_bin->readBytes(resolved, 8); + if (gb.size() >= 8) + { + uint64_t target = gb[0] | ((uint64_t)gb[1] << 8) | + ((uint64_t)gb[2] << 16) | ((uint64_t)gb[3] << 24) | + ((uint64_t)gb[4] << 32) | ((uint64_t)gb[5] << 40) | + ((uint64_t)gb[6] << 48) | ((uint64_t)gb[7] << 56); + if (target && target < 0x100000000ULL) resolved = target; + } + m_funcs.insert(resolved); + recordIndirect(inst, resolved, true, nm, lb); + } + else + { + string reg = inst.operands; + while (!reg.empty() && reg[0] == ' ') reg = reg.substr(1); + resolved = traceReg(reg, block.instructions, block.instructions.size() - 1); + if (resolved) + { + m_funcs.insert(resolved); + recordIndirect(inst, resolved, true, "traced", ""); + } + else + { + recordIndirect(inst, 0, false, "unresolved", ""); + } + } + } + } + + cur += inst.size; + next = cur; + } + + return block; +} + +set CFGBuilder::findPrologs() +{ + set cand; + auto ranges = m_bin->getExecutableRanges(); + + for (const auto& r : ranges) + { + addr_t a = r.first; + while (a < r.second) + { + auto bytes = m_bin->readBytes(a, 15); + if (bytes.empty()) { a += 1; continue; } + auto insts = m_dis->disassemble(bytes, a, 1); + if (insts.empty()) { a += 1; continue; } + auto& inst = insts[0]; + + if (inst.mnemonic == "endbr64") + { + auto nb = m_bin->readBytes(a + inst.size, 15); + auto ni = m_dis->disassemble(nb, a + inst.size, 2); + if (!ni.empty() && m_dis->isProlog(ni)) cand.insert(a); + } + else + { + vector tmp{inst}; + if (m_dis->isProlog(tmp)) cand.insert(a); + } + + a += inst.size; + } + } + + return cand; +} + +Function CFGBuilder::buildFunction(addr_t start, const string& name) +{ + Function func; + func.address = start; + func.name = name; + + queue q; + q.push(start); + + while (!q.empty()) + { + addr_t a = q.front(); q.pop(); + if (isVisited(a)) continue; + markVisited(a); + + addr_t nxt = a; + auto block = disassembleBlock(a, nxt); + for (auto s : block.successors) + if (!isVisited(s)) q.push(s); + + func.blocks.push_back(block); + } + + return func; +} + +CFG CFGBuilder::build() +{ + CFG cfg; + cfg.binary_path = m_bin->getPath(); + cfg.entry_point = m_bin->getEntryPoint(); + + switch (m_bin->getArch()) + { + case Arch::X86: cfg.arch_str = "x86"; break; + case Arch::X64: cfg.arch_str = "x86-64"; break; + default: cfg.arch_str = "unknown"; + } + switch (m_bin->getFormat()) + { + case BinaryFormat::PE: cfg.format_str = "PE"; break; + case BinaryFormat::ELF: cfg.format_str = "ELF"; break; + default: cfg.format_str = "unknown"; + } + + cfg.imports = m_bin->getImportedFunctions(); + buildGotMap(); + + m_prologs = findPrologs(); + + set built; + queue pending; + + auto process = [&](addr_t addr, const string& name) + { + if (built.count(addr)) return; + built.insert(addr); + + auto func = buildFunction(addr, name); + cfg.functions.push_back(func); + + for (const auto& b : func.blocks) + for (const auto& inst : b.instructions) + if (m_dis->isCall(inst)) + { + addr_t t = m_dis->getBranchTarget(inst); + if (t && !m_dis->isIndirectBranch(inst)) + m_funcs.insert(t); + } + + for (auto d : m_funcs) + if (!built.count(d)) pending.push(d); + }; + + { + addr_t ep = m_bin->getEntryPoint(); + string ep_name = "entry"; + for (const auto& exp : m_bin->getExportedFunctions()) + if (exp.first == ep) { ep_name = exp.second; break; } + process(ep, ep_name); + } + + for (const auto& exp : m_bin->getExportedFunctions()) + pending.push(exp.first); + + map imp_map; + for (const auto& imp : m_bin->getImportedFunctions()) + imp_map[imp.address] = imp.name; + + while (!pending.empty()) + { + addr_t a = pending.front(); pending.pop(); + if (built.count(a)) continue; + + string name; + for (const auto& exp : m_bin->getExportedFunctions()) + if (exp.first == a) { name = exp.second; break; } + if (name.empty()) + { + auto it = imp_map.find(a); + if (it != imp_map.end()) name = it->second; + } + + built.insert(a); + auto func = buildFunction(a, name); + cfg.functions.push_back(func); + + for (const auto& b : func.blocks) + for (const auto& inst : b.instructions) + if (m_dis->isCall(inst)) + { + addr_t t = m_dis->getBranchTarget(inst); + if (t && !m_dis->isIndirectBranch(inst)) + if (!built.count(t)) pending.push(t); + } + + for (auto p : m_prologs) + if (!built.count(p)) pending.push(p); + } + + cfg.indirect_targets = m_targets; + return cfg; +} diff --git a/cfg/builder.hpp b/cfg/builder.hpp new file mode 100644 index 0000000..106d95e --- /dev/null +++ b/cfg/builder.hpp @@ -0,0 +1,35 @@ +#pragma once +#include "types.hpp" +#include "loader/binary.hpp" +#include "disasm/engine.hpp" +#include +#include +#include + +class CFGBuilder +{ + public: + CFGBuilder(Binary* binary, Disassembler* disasm); + CFG build(); + + private: + void buildGotMap(); + Function buildFunction(addr_t start, const string& name); + BasicBlock disassembleBlock(addr_t start, addr_t& next); + set findPrologs(); + void markVisited(addr_t addr); + bool isVisited(addr_t addr); + + addr_t resolveGOT(const Instruction& inst); + addr_t resolveJumpTable(const vector& block, const Instruction& inst); + addr_t traceReg(const string& reg, const vector& block, size_t idx); + void recordIndirect(const Instruction& inst, addr_t target, bool ok, const string& name, const string& lib); + + Binary* m_bin; + Disassembler* m_dis; + set m_funcs; + set m_blocks; + set m_prologs; + map> m_got; + vector m_targets; +}; diff --git a/disasm/engine.cpp b/disasm/engine.cpp new file mode 100644 index 0000000..ecf0bb8 --- /dev/null +++ b/disasm/engine.cpp @@ -0,0 +1,163 @@ +#include "disasm/engine.hpp" +#include + +Disassembler::Disassembler() : m_handle(0), m_initialized(false) {} +Disassembler::~Disassembler() +{ + if (m_initialized) cs_close(&m_handle); +} + +bool Disassembler::init(Arch arch) +{ + cs_arch a; + cs_mode m; + if (arch == Arch::X64) { a = CS_ARCH_X86; m = CS_MODE_64; } + else if (arch == Arch::X86) { a = CS_ARCH_X86; m = CS_MODE_32; } + else return false; + + if (cs_open(a, m, &m_handle) != CS_ERR_OK) return false; + cs_option(m_handle, CS_OPT_DETAIL, CS_OPT_ON); + m_initialized = true; + return true; +} + +vector Disassembler::disassemble(const vector& bytes, addr_t base, size_t count) +{ + vector result; + if (!m_initialized || bytes.empty()) return result; + + const uint8_t* code = bytes.data(); + size_t size = bytes.size(); + addr_t addr = base; + size_t n = count ? count : size; + + cs_insn* insn = cs_malloc(m_handle); + if (!insn) return result; + + while (cs_disasm_iter(m_handle, &code, &size, &addr, insn)) + { + Instruction inst; + inst.address = insn->address; + inst.mnemonic = insn->mnemonic; + inst.operands = insn->op_str; + inst.size = static_cast(insn->size); + inst.bytes.assign(insn->bytes, insn->bytes + insn->size); + result.push_back(inst); + + if (count && result.size() >= count) break; + } + + cs_free(insn, 1); + return result; +} + +bool Disassembler::isProlog(const vector& insts) const +{ + for (const auto& inst : insts) + { + if (inst.mnemonic == "push" && (inst.operands == "rbp" || inst.operands == "ebp")) + return true; + } + return false; +} + +bool Disassembler::isEpilog(const Instruction& inst) const +{ + return inst.mnemonic == "leave" || inst.mnemonic == "ret" || inst.mnemonic == "retf"; +} + +bool Disassembler::isReturn(const Instruction& inst) const +{ + return inst.mnemonic == "ret" || inst.mnemonic == "retf" || inst.mnemonic == "iret" || inst.mnemonic == "iretd"; +} + +bool Disassembler::isTrap(const Instruction& inst) const +{ + return inst.mnemonic == "hlt" || inst.mnemonic == "ud2" || inst.mnemonic == "int3" || inst.mnemonic == "ud0"; +} + +bool Disassembler::isCall(const Instruction& inst) const +{ + return inst.mnemonic == "call"; +} + +bool Disassembler::isUnconditionalBranch(const Instruction& inst) const +{ + return inst.mnemonic == "jmp" || inst.mnemonic == "ljmp"; +} + +bool Disassembler::isConditionalBranch(const Instruction& inst) const +{ + return inst.mnemonic.size() == 2 && inst.mnemonic[0] == 'j' && inst.mnemonic != "jmp"; +} + +bool Disassembler::isIndirectBranch(const Instruction& inst) const +{ + const string& ops = inst.operands; + if (inst.mnemonic == "call" || inst.mnemonic == "jmp") + { + if (ops.find('[') != string::npos) return true; + if (ops.size() >= 3 && ops[0] == 'r' && isdigit(ops[1])) return true; + if (ops.size() >= 4 && ops[0] == 'r' && ops[1] == '1' && isdigit(ops[2])) return true; + if (ops.size() >= 3 && ops[0] == 'e' && isdigit(ops[1])) return true; + if (ops[0] == '*') return true; + } + return false; +} + +addr_t Disassembler::getBranchTarget(const Instruction& inst) const +{ + const string& ops = inst.operands; + if (ops.empty()) return 0; + + size_t pos = string::npos; + if (ops[0] == '0' && ops.size() > 2 && ops[1] == 'x') + pos = 0; + else if (ops[0] >= '0' && ops[0] <= '9') + pos = 0; + else + pos = ops.find("0x"); + + if (pos == string::npos) return 0; + + try { + return stoull(ops.substr(pos), nullptr, 16); + } catch (...) { + return 0; + } +} + +int64_t Disassembler::getRIPDisp(const Instruction& inst) const +{ + if (!m_initialized) return 0; + + auto bytes = inst.bytes; + if (bytes.empty()) return 0; + + cs_insn* insn = cs_malloc(m_handle); + if (!insn) return 0; + + const uint8_t* code = bytes.data(); + size_t size = bytes.size(); + addr_t addr = inst.address; + int64_t disp = 0; + + if (cs_disasm_iter(m_handle, &code, &size, &addr, insn)) + { + if (insn->detail) + { + for (int i = 0; i < insn->detail->x86.op_count; i++) + { + const auto& op = insn->detail->x86.operands[i]; + if (op.type == X86_OP_MEM && op.mem.base == X86_REG_RIP) + { + disp = op.mem.disp; + break; + } + } + } + } + + cs_free(insn, 1); + return disp; +} diff --git a/disasm/engine.hpp b/disasm/engine.hpp new file mode 100644 index 0000000..fd274e0 --- /dev/null +++ b/disasm/engine.hpp @@ -0,0 +1,28 @@ +#pragma once +#include "types.hpp" +#include "loader/binary.hpp" +#include + +class Disassembler +{ + public: + Disassembler(); + ~Disassembler(); + + bool init(Arch arch); + vector disassemble(const vector& bytes, addr_t base, size_t count = 0); + bool isProlog(const vector& insts) const; + bool isEpilog(const Instruction& inst) const; + bool isReturn(const Instruction& inst) const; + bool isTrap(const Instruction& inst) const; + bool isCall(const Instruction& inst) const; + bool isUnconditionalBranch(const Instruction& inst) const; + bool isConditionalBranch(const Instruction& inst) const; + bool isIndirectBranch(const Instruction& inst) const; + addr_t getBranchTarget(const Instruction& inst) const; + int64_t getRIPDisp(const Instruction& inst) const; + + private: + csh m_handle; + bool m_initialized; +}; diff --git a/loader/binary.cpp b/loader/binary.cpp new file mode 100644 index 0000000..2136a62 --- /dev/null +++ b/loader/binary.cpp @@ -0,0 +1,15 @@ +#include "loader/binary.hpp" +#include "loader/elf.hpp" +#include "loader/pe.hpp" +#include + +unique_ptr Binary::create(const string& path) +{ + auto elf = make_unique(); + if (elf->load(path)) return elf; + + auto pe = make_unique(); + if (pe->load(path)) return pe; + + return nullptr; +} diff --git a/loader/binary.hpp b/loader/binary.hpp new file mode 100644 index 0000000..1e3bd63 --- /dev/null +++ b/loader/binary.hpp @@ -0,0 +1,39 @@ +#pragma once +#include "types.hpp" + + + +enum class BinaryFormat +{ + PE, + ELF, + UNKNOWN +}; + +enum class Arch +{ + X86, + X64, + UNKNOWN +}; + +class Binary +{ + public: + virtual ~Binary() = default; + virtual bool load(const string& path) = 0; + virtual BinaryFormat getFormat() const = 0; + virtual Arch getArch() const = 0; + virtual addr_t getEntryPoint() const = 0; + virtual addr_t getImageBase() const = 0; + virtual vector readBytes(addr_t vaddr, size_t size) const = 0; + virtual vector> getExecutableRanges() const = 0; + virtual vector> getExportedFunctions() const = 0; + virtual vector getImportedFunctions() const + { + return {}; + } + virtual const string& getPath() const = 0; + + static unique_ptr create(const string& path); +}; diff --git a/loader/elf.cpp b/loader/elf.cpp new file mode 100644 index 0000000..217e3ef --- /dev/null +++ b/loader/elf.cpp @@ -0,0 +1,332 @@ +#include "loader/elf.hpp" +#include +#include + +static const uint64_t EI_NIDENT = 16; +static const uint32_t PT_LOAD = 1; +static const uint32_t PT_DYNAMIC = 2; +static const uint32_t DT_NULL = 0; +static const uint32_t DT_NEEDED = 1; +static const uint32_t DT_INIT = 12; +static const uint32_t DT_FINI = 13; +static const uint32_t DT_INIT_ARRAY = 25; +static const uint32_t DT_FINI_ARRAY = 26; +static const uint32_t DT_INIT_ARRAYSZ = 27; +static const uint32_t DT_FINI_ARRAYSZ = 28; +static const uint32_t DT_STRTAB = 5; +static const uint32_t DT_SYMTAB = 6; +static const uint32_t DT_STRSZ = 10; +static const uint32_t SHT_SYMTAB = 2; +static const uint32_t SHT_DYNSYM = 11; + +ELFLoader::ELFLoader() + : m_arch(Arch::X64), m_entry(0), + m_init_array(0), m_init_array_size(0), + m_fini_array(0), m_fini_array_size(0), + m_init(0), m_fini(0) {} + +ELFLoader::~ELFLoader() {} + +bool ELFLoader::load(const string& path) +{ + m_path = path; + ifstream f(path, ios::binary); + if (!f) return false; + + f.seekg(0, ios::end); + size_t sz = f.tellg(); + f.seekg(0, ios::beg); + + m_data.resize(sz); + f.read((char*)m_data.data(), sz); + f.close(); + + if (m_data.size() < EI_NIDENT) return false; + if (m_data[0] != 0x7F || m_data[1] != 'E' || m_data[2] != 'L' || m_data[3] != 'F') + return false; + + return parseHeader(); +} + +static uint16_t r16(const vector& d, size_t off) +{ + if (off + 2 > d.size()) return 0; + return d[off] | (d[off+1] << 8); +} + +static uint32_t r32(const vector& d, size_t off) +{ + if (off + 4 > d.size()) return 0; + return d[off] | (d[off+1] << 8) | (d[off+2] << 16) | (d[off+3] << 24); +} + +static uint64_t r64(const vector& d, size_t off) +{ + if (off + 8 > d.size()) return 0; + return (uint64_t)d[off] | ((uint64_t)d[off+1] << 8) | + ((uint64_t)d[off+2] << 16) | ((uint64_t)d[off+3] << 24) | + ((uint64_t)d[off+4] << 32) | ((uint64_t)d[off+5] << 40) | + ((uint64_t)d[off+6] << 48) | ((uint64_t)d[off+7] << 56); +} + +struct Elf64_Ehdr +{ + uint8_t ident[16]; + uint16_t type; + uint16_t machine; + uint32_t version; + uint64_t entry; + uint64_t phoff; + uint64_t shoff; + uint32_t flags; + uint16_t ehsize; + uint16_t phentsize; + uint16_t phnum; + uint16_t shentsize; + uint16_t shnum; + uint16_t shstrndx; +}; + +struct Elf64_Phdr +{ + uint32_t type; + uint32_t flags; + uint64_t offset; + uint64_t vaddr; + uint64_t paddr; + uint64_t filesz; + uint64_t memsz; + uint64_t align; +}; + +struct Elf64_Shdr +{ + uint32_t name; + uint32_t type; + uint64_t flags; + uint64_t addr; + uint64_t offset; + uint64_t size; + uint32_t link; + uint32_t info; + uint64_t addralign; + uint64_t entsize; +}; + +struct Elf64_Dyn +{ + int64_t d_tag; + uint64_t d_val; +}; + +bool ELFLoader::parseHeader() +{ + if (m_data.size() < 64) return false; + + uint8_t cls = m_data[4]; + bool is_64 = (cls == 2); + + if (is_64) + { + m_arch = Arch::X64; + if (m_data.size() < 64) return false; + uint16_t type = r16(m_data, 16); + m_entry = r64(m_data, 24); + uint64_t phoff = r64(m_data, 32); + uint64_t shoff = r64(m_data, 40); + uint16_t phnum = r16(m_data, 56); + uint16_t shnum = r16(m_data, 60); + uint16_t shstrndx = r16(m_data, 62); + + for (uint16_t i = 0; i < phnum; i++) + { + size_t off = phoff + i * 56; + if (off + 56 > m_data.size()) break; + uint32_t ptype = r32(m_data, off); + uint32_t pflags = r32(m_data, off + 4); + uint64_t poffset = r64(m_data, off + 8); + uint64_t pvaddr = r64(m_data, off + 16); + uint64_t pfilesz = r64(m_data, off + 32); + uint64_t pmemsz = r64(m_data, off + 40); + + if (ptype == PT_LOAD && (pflags & 1)) + { + m_exec_ranges.push_back({pvaddr, pvaddr + pmemsz}); + } + + if (ptype == PT_DYNAMIC) + { + addr_t dyn_va = pvaddr; + size_t dyn_sz = pmemsz; + size_t dyn_off = poffset; + + size_t end = dyn_off + dyn_sz; + for (size_t j = dyn_off; j + 16 <= end; j += 16) + { + int64_t tag = (int64_t)r64(m_data, j); + uint64_t val = r64(m_data, j + 8); + + if (tag == DT_NULL) break; + if (tag == DT_NEEDED && val) + { + uint64_t strtab = 0; + for (size_t k = dyn_off; k + 16 <= end; k += 16) + { + int64_t t2 = (int64_t)r64(m_data, k); + uint64_t v2 = r64(m_data, k + 8); + if (t2 == DT_STRTAB) { strtab = v2; break; } + } + if (strtab) + { + size_t name_off = strtab + val; + if (name_off < m_data.size()) + { + string lib; + for (size_t c = name_off; c < m_data.size() && m_data[c]; c++) + lib += (char)m_data[c]; + ImportEntry e; + e.address = 0; + e.name = lib; + e.library = lib; + m_imports.push_back(e); + } + } + } + if (tag == DT_INIT) m_init = val; + if (tag == DT_FINI) m_fini = val; + if (tag == DT_INIT_ARRAY) m_init_array = val; + if (tag == DT_INIT_ARRAYSZ) m_init_array_size = val; + if (tag == DT_FINI_ARRAY) m_fini_array = val; + if (tag == DT_FINI_ARRAYSZ) m_fini_array_size = val; + } + } + } + + for (uint16_t i = 0; i < shnum; i++) + { + size_t off = shoff + i * 64; + if (off + 64 > m_data.size()) break; + uint32_t stype = r32(m_data, off + 4); + + if (stype == SHT_DYNSYM || stype == SHT_SYMTAB) + { + uint64_t sym_off = r64(m_data, off + 24); + uint64_t sym_sz = r64(m_data, off + 32); + uint32_t link = r32(m_data, off + 40); + uint64_t entsize = r64(m_data, off + 56); + if (entsize == 0) entsize = 24; + + uint64_t strtab_off = 0; + uint64_t strtab_sz = 0; + for (uint16_t k = 0; k < shnum; k++) + { + size_t soff = shoff + k * 64; + if (soff + 64 > m_data.size()) break; + if (r32(m_data, soff + 4) == SHT_SYMTAB || r32(m_data, soff + 4) == SHT_DYNSYM) + continue; + if ((uint32_t)k == link) + { + strtab_off = r64(m_data, soff + 24); + strtab_sz = r64(m_data, soff + 32); + break; + } + } + + size_t nsym = sym_sz / entsize; + for (size_t j = 0; j < nsym; j++) + { + size_t sym_ent = sym_off + j * entsize; + if (sym_ent + 16 > m_data.size()) break; + uint32_t sym_name_off = r32(m_data, sym_ent); + uint8_t sym_info = m_data[sym_ent + 4]; + uint64_t sym_val = r64(m_data, sym_ent + 8); + + uint8_t sym_type = sym_info & 0xF; + uint8_t sym_bind = sym_info >> 4; + + if (sym_val && sym_type == 2 && sym_name_off && strtab_off) + { + size_t name_pos = strtab_off + sym_name_off; + if (name_pos < m_data.size()) + { + string sym_name; + for (size_t c = name_pos; c < m_data.size() && m_data[c]; c++) + sym_name += (char)m_data[c]; + if (!sym_name.empty()) + { + m_symbols[sym_val] = sym_name; + if (sym_bind == 0) m_exports.push_back({sym_val, sym_name}); + } + } + } + } + } + + if (stype == SHT_DYNSYM) break; + } + } + else + { + m_arch = Arch::X86; + } + + return true; +} + +bool ELFLoader::parseDynamic() +{ + return true; +} + +bool ELFLoader::parseSections() +{ + return true; +} + +bool ELFLoader::parseSymbols() +{ + return true; +} + +vector ELFLoader::readBytes(addr_t vaddr, size_t size) const +{ + vector result; + for (const auto& r : m_exec_ranges) + { + if (vaddr >= r.first && vaddr < r.second) + { + addr_t offset = vaddr; + for (const auto& r2 : m_exec_ranges) + { + if (offset >= r2.first && offset < r2.second) + { + addr_t file_off = 0; + size_t max_read = min(size, (size_t)(r2.second - offset)); + size_t copy_start = offset - r2.first; + if (copy_start < m_data.size()) + { + size_t to_copy = min(max_read, m_data.size() - copy_start); + result.assign(m_data.begin() + copy_start, m_data.begin() + copy_start + to_copy); + } + return result; + } + } + } + } + return result; +} + +vector> ELFLoader::getExecutableRanges() const +{ + return m_exec_ranges; +} + +vector> ELFLoader::getExportedFunctions() const +{ + return m_exports; +} + +vector ELFLoader::getImportedFunctions() const +{ + return m_imports; +} diff --git a/loader/elf.hpp b/loader/elf.hpp new file mode 100644 index 0000000..792a699 --- /dev/null +++ b/loader/elf.hpp @@ -0,0 +1,52 @@ +#pragma once +#include "loader/binary.hpp" +#include +#include +#include + +class ELFLoader : public Binary +{ + public: + ELFLoader(); + ~ELFLoader() override; + + bool load(const string& path) override; + BinaryFormat getFormat() const override { return BinaryFormat::ELF; } + Arch getArch() const override { return m_arch; } + addr_t getEntryPoint() const override { return m_entry; } + addr_t getImageBase() const override { return 0; } + vector readBytes(addr_t vaddr, size_t size) const override; + vector> getExecutableRanges() const override; + vector> getExportedFunctions() const override; + vector getImportedFunctions() const override; + const string& getPath() const override { return m_path; } + + addr_t getInitArray() const { return m_init_array; } + addr_t getFiniArray() const { return m_fini_array; } + size_t getInitArraySize() const { return m_init_array_size; } + size_t getFiniArraySize() const { return m_fini_array_size; } + addr_t getInit() const { return m_init; } + addr_t getFini() const { return m_fini; } + + private: + bool parseHeader(); + bool parseDynamic(); + bool parseSections(); + bool parseSymbols(); + + string m_path; + Arch m_arch; + addr_t m_entry; + vector m_data; + vector> m_exec_ranges; + vector> m_exports; + vector m_imports; + map m_symbols; + + addr_t m_init_array; + size_t m_init_array_size; + addr_t m_fini_array; + size_t m_fini_array_size; + addr_t m_init; + addr_t m_fini; +}; diff --git a/loader/pe.cpp b/loader/pe.cpp new file mode 100644 index 0000000..a262e7c --- /dev/null +++ b/loader/pe.cpp @@ -0,0 +1,276 @@ +#include "loader/pe.hpp" +#include +#include + +PELoader::PELoader() : m_arch(Arch::X64), m_entry(0), m_image_base(0) {} +PELoader::~PELoader() {} + +bool PELoader::load(const string& path) +{ + m_path = path; + ifstream f(path, ios::binary); + if (!f) return false; + + f.seekg(0, ios::end); + size_t sz = f.tellg(); + f.seekg(0, ios::beg); + + m_data.resize(sz); + f.read((char*)m_data.data(), sz); + f.close(); + + return parseHeaders(); +} + +static uint16_t r16(const vector& d, size_t off) +{ + if (off + 2 > d.size()) return 0; + return d[off] | (d[off+1] << 8); +} + +static uint32_t r32(const vector& d, size_t off) +{ + if (off + 4 > d.size()) return 0; + return d[off] | (d[off+1] << 8) | (d[off+2] << 16) | (d[off+3] << 24); +} + +static uint64_t r64(const vector& d, size_t off) +{ + if (off + 8 > d.size()) return 0; + return (uint64_t)d[off] | ((uint64_t)d[off+1] << 8) | + ((uint64_t)d[off+2] << 16) | ((uint64_t)d[off+3] << 24) | + ((uint64_t)d[off+4] << 32) | ((uint64_t)d[off+5] << 40) | + ((uint64_t)d[off+6] << 48) | ((uint64_t)d[off+7] << 56); +} + +bool PELoader::parseHeaders() +{ + if (m_data.size() < 64) return false; + if (r16(m_data, 0) != 0x5A4D) return false; + + uint32_t pe_off = r32(m_data, 0x3C); + if (pe_off + 4 > m_data.size()) return false; + if (r32(m_data, pe_off) != 0x00004550) return false; + + uint16_t machine = r16(m_data, pe_off + 4); + uint16_t num_sections = r16(m_data, pe_off + 6); + + if (machine == 0x8664) m_arch = Arch::X64; + else if (machine == 0x14C) m_arch = Arch::X86; + else return false; + + uint16_t opt_hdr_size = r16(m_data, pe_off + 20); + uint32_t opt_hdr_off = pe_off + 24; + + if (opt_hdr_off + 2 > m_data.size()) return false; + uint16_t magic = r16(m_data, opt_hdr_off); + + if (magic == 0x10B) + { + m_arch = Arch::X86; + m_image_base = r32(m_data, opt_hdr_off + 28); + m_entry = r32(m_data, opt_hdr_off + 16) + m_image_base; + } + else if (magic == 0x20B) + { + m_arch = Arch::X64; + m_image_base = r64(m_data, opt_hdr_off + 24); + m_entry = r32(m_data, opt_hdr_off + 16) + m_image_base; + } + else return false; + + uint16_t section_hdr_size = 40; + uint32_t sections_off = opt_hdr_off + opt_hdr_size; + + struct Section + { + string name; + addr_t vaddr; + uint32_t vsize; + uint32_t raw_ptr; + uint32_t raw_size; + uint32_t characteristics; + }; + vector
sections; + + for (uint16_t i = 0; i < num_sections; i++) + { + uint32_t off = sections_off + i * section_hdr_size; + if (off + section_hdr_size > m_data.size()) break; + + char name_buf[9] = {}; + memcpy(name_buf, &m_data[off], 8); + Section s; + s.name = name_buf; + s.vsize = r32(m_data, off + 8); + s.vaddr = r32(m_data, off + 12) + m_image_base; + s.raw_size = r32(m_data, off + 16); + s.raw_ptr = r32(m_data, off + 20); + s.characteristics = r32(m_data, off + 36); + sections.push_back(s); + } + + for (const auto& s : sections) + { + if (s.characteristics & 0x20000000) + { + addr_t start = s.vaddr; + addr_t end = start + (s.vsize ? s.vsize : s.raw_size); + m_exec_ranges.push_back({start, end}); + } + } + + bool is_64 = (m_arch == Arch::X64); + uint32_t import_rva = 0; + uint32_t data_dir_off = (magic == 0x10B) ? opt_hdr_off + 96 : opt_hdr_off + 112; + import_rva = r32(m_data, data_dir_off + 8); + + auto rvaToOffset = [&](uint32_t rva) -> uint32_t { + for (const auto& s : sections) + { + addr_t va = rva + m_image_base; + if (va >= s.vaddr && va < s.vaddr + (s.vsize ? s.vsize : s.raw_size)) + return s.raw_ptr + static_cast(va - s.vaddr); + } + return 0; + }; + + auto readString = [&](uint32_t off) -> string { + string s; + for (size_t c = off; c < m_data.size() && m_data[c]; c++) + s += (char)m_data[c]; + return s; + }; + + if (import_rva) + { + uint32_t desc_off = rvaToOffset(import_rva); + + for (uint32_t i = 0; ; i++) + { + uint32_t desc = desc_off + i * 20; + if (desc + 20 > m_data.size()) break; + + uint32_t oft_rva = r32(m_data, desc); + if (oft_rva == 0) break; + + uint32_t name_rva = r32(m_data, desc + 12); + string dll_name; + if (name_rva) + { + uint32_t name_off = rvaToOffset(name_rva); + if (name_off) dll_name = readString(name_off); + } + if (dll_name.empty()) continue; + + uint32_t thunk_rva = r32(m_data, desc + 16); + if (thunk_rva == 0) thunk_rva = oft_rva; + + uint32_t thunk_off = rvaToOffset(thunk_rva); + if (!thunk_off) continue; + + size_t entry_size = is_64 ? 8 : 4; + uint64_t ordinal_flag = is_64 ? 0x8000000000000000ULL : 0x80000000; + + for (uint32_t j = 0; ; j++) + { + uint32_t entry = static_cast(thunk_off + j * entry_size); + if (entry + entry_size > m_data.size()) break; + + uint64_t val = is_64 ? r64(m_data, entry) : r32(m_data, entry); + if (val == 0) break; + + string func_name; + if (val & ordinal_flag) + { + func_name = "ord_" + to_string(val & 0xFFFF); + } + else + { + addr_t hint_va = val + m_image_base; + uint32_t hint_off = rvaToOffset(static_cast(val)); + if (hint_off && hint_off + 2 < m_data.size()) + func_name = readString(hint_off + 2); + } + + addr_t iat_addr = thunk_rva + m_image_base + j * entry_size; + ImportEntry e; + e.address = iat_addr; + e.name = func_name; + e.library = dll_name; + m_imports.push_back(e); + } + } + } + + return true; +} + +bool PELoader::parseImportTable() +{ + return true; +} + +bool PELoader::parseExportTable() +{ + return true; +} + +vector PELoader::readBytes(addr_t vaddr, size_t size) const +{ + vector result; + uint32_t off = 0; + uint32_t raw_off = 0; + uint32_t raw_end = 0; + + uint16_t num_sections = r16(m_data, r32(m_data, 0x3C) + 6); + uint32_t pe_off = r32(m_data, 0x3C); + uint16_t opt_sz = r16(m_data, pe_off + 20); + uint32_t sections_off = pe_off + 24 + opt_sz; + + for (uint16_t i = 0; i < num_sections; i++) + { + uint32_t so = sections_off + i * 40; + if (so + 40 > m_data.size()) break; + addr_t sva = r32(m_data, so + 12) + m_image_base; + uint32_t svs = r32(m_data, so + 8); + uint32_t srs = r32(m_data, so + 16); + uint32_t srp = r32(m_data, so + 20); + addr_t end = sva + (svs ? svs : srs); + + if (vaddr >= sva && vaddr < end) + { + off = srp + static_cast(vaddr - sva); + raw_off = srp; + raw_end = srp + srs; + break; + } + } + + if (!off) return result; + + size_t available = (raw_end > off) ? (raw_end - off) : 0; + size_t to_read = min(size, available); + if (off + to_read > m_data.size()) + to_read = m_data.size() - off; + + if (to_read > 0) + result.assign(m_data.begin() + off, m_data.begin() + off + to_read); + + return result; +} + +vector> PELoader::getExecutableRanges() const +{ + return m_exec_ranges; +} + +vector> PELoader::getExportedFunctions() const +{ + return m_exports; +} + +vector PELoader::getImportedFunctions() const +{ + return m_imports; +} diff --git a/loader/pe.hpp b/loader/pe.hpp new file mode 100644 index 0000000..08af043 --- /dev/null +++ b/loader/pe.hpp @@ -0,0 +1,37 @@ +#pragma once +#include "loader/binary.hpp" +#include +#include +#include + +class PELoader : public Binary +{ + public: + PELoader(); + ~PELoader() override; + + bool load(const string& path) override; + BinaryFormat getFormat() const override { return BinaryFormat::PE; } + Arch getArch() const override { return m_arch; } + addr_t getEntryPoint() const override { return m_entry; } + addr_t getImageBase() const override { return m_image_base; } + vector readBytes(addr_t vaddr, size_t size) const override; + vector> getExecutableRanges() const override; + vector> getExportedFunctions() const override; + vector getImportedFunctions() const override; + const string& getPath() const override { return m_path; } + + private: + bool parseHeaders(); + bool parseImportTable(); + bool parseExportTable(); + + string m_path; + Arch m_arch; + addr_t m_entry; + addr_t m_image_base; + vector m_data; + vector> m_exec_ranges; + vector> m_exports; + vector m_imports; +}; diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..d49e411 --- /dev/null +++ b/main.cpp @@ -0,0 +1,74 @@ +#include "types.hpp" +#include "loader/binary.hpp" +#include "cfg/builder.hpp" +#include "disasm/engine.hpp" + +int main(int argc, char* argv[]) +{ + if (argc < 2) + { + cerr << "usage: cfgrip " << endl; + return 1; + } + + string path = argv[1]; + + auto binary = Binary::create(path); + if (!binary) + { + cerr << "failed to load binary: " << path << endl; + return 1; + } + + cout << "format: "; + switch (binary->getFormat()) + { + case BinaryFormat::PE: cout << "PE"; break; + case BinaryFormat::ELF: cout << "ELF"; break; + default: cout << "unknown"; + } + cout << endl; + + cout << "arch: "; + switch (binary->getArch()) + { + case Arch::X86: cout << "x86"; break; + case Arch::X64: cout << "x86-64"; break; + default: cout << "unknown"; + } + cout << endl; + + cout << "entry: 0x" << hex << binary->getEntryPoint() << dec << endl; + cout << "imports: " << binary->getImportedFunctions().size() << endl; + + for (const auto& imp : binary->getImportedFunctions()) + { + cout << " 0x" << hex << imp.address << " " << imp.name; + if (!imp.library.empty()) cout << " (" << imp.library << ")"; + cout << dec << endl; + } + + Disassembler dis; + if (!dis.init(binary->getArch())) + { + cerr << "failed to init capstone" << endl; + return 1; + } + + CFGBuilder builder(binary.get(), &dis); + CFG cfg = builder.build(); + + cout << "functions: " << cfg.functions.size() << endl; + cout << "indirect targets: " << cfg.indirect_targets.size() << endl; + + string out = path + ".cfg"; + ofstream f(out); + if (f) + { + f << cfg.toJSON(); + f.close(); + cout << "cfg written to: " << out << endl; + } + + return 0; +} diff --git a/tests/example1.exe b/tests/example1.exe new file mode 100644 index 0000000000000000000000000000000000000000..5276f52de39248fca54926dd3c6a20e51f9c3f8f GIT binary patch literal 210944 zcmeFadwf*Yx%fTF%)kH%dr%@lQAQbSELNk@nm8geWFmWHB0-^~DiRw-tf&YxfEBqo zNt6RIJ+`%%)7qY1tn~u4)m)H-`>j^cs%U%aiX%1JHUhQI`+e5llMBYS=l%UY z?_Y0}*?X_OuFrbbb6;!MUbEiicDY<0{^fEm*9NZg7uLW3{HKT4qbF_}?Rs*=&eJy( z#CM)Pd*Llh1B;j3ar2TJZVNQtaQp3dBm$qiDX=7Yd*GJa1JRjR2X4FL#+%M9E*=?l zs&0AdsoQq^>gCJw|DL+!)v34g{M03{O?^dQ4@}*xuP;sAt@FKf+0VJoxZuFlE&BS} z)Zgptt5YB0I{$)Kr|#6(gZg^aEsYDM?)*sVYFw@xzc|eG*3}1Z$*1+W&Tx$?9DR=K z?E;spfq(q{dNx0PeH+#(a$o3j4bw^eSJxV#C&1&+?P^$?FXWUZ)vhFek$g^y+`4w; z3SDLT&iM&b%V`4=7Q0=+5iZx`TMJ#%rH}ht+*RnZJDSf?=z5&~e%#-=iJMj=c=^a% zj7~ZvV|T`pFB1S7=PtSNhQtjn*B&451pp(t_Q-wzUl?>b*UsizBZKh+lM}ce8{7f% zwVu1!&Zx)8SX}|~6$u9R|AnQ#1&b3md~VTAE@`TP_fpk4AIaBx?vk4p-O=dMFmeGa z*GTf6`;mOpNd5o+hJb*Xdb=#LQGje_N~WIRcGXn0nwjF~$GBZ8SSqQ-X; zch}`i%+-_#=mN_19sPa;rA+I9`l`bW?5Ek)1+ML0 zL4BrGvT>~270-CDB2PT+{UuLk^S;E1rd4P*nx1$%I;JjedH++=t&&Ha*F^(gckI|9 zI-#IsNuaJNEli>8q-<-~TlKz6Y8>*&p%T{YU%$Z*qUYzCW7|ckhsU zyN(!LP(^kfwRzb5g!eo6Gt<`v{bo8544CP7&^I?SJ2EHonaEtqE{B6^A3% zKceYHWU;m>>y-jm-0F#2!)h6A%)0LUGPC*RRU^&NfmL2}@`0>7X1x-(J~Y!$1|Mgd zVpjZo(`??F7-m`pxjLU|4HGa`tvugvG%sc%O)}I;hEvSYuEa^|l%~Yi;5j3q?^;ThX>#CD;UFky8 ziiJ&UjG38MV5SSAErk)QH9I0=?a`epO&!T4{hNfWSjW<{gMsev38Lk;3zW*TUvb)T zS}3Tsw#2O8=IYE?XiK7aK(Xu{(yg2RuXbxt{YGD(zNVXXT8gI^onMwclNobTpA0@K zV_6vt#I0ZJ>BtUu`k5a~YUTN+D`M2VFzUrov(NXZ-WZqWGHLetW0N)NUMOu-Ytk39 zcB}t@s>iJ1GI>{6@u~rH>Nl+|@yvC>#WCyJ%9yp(j9Gt(%#U0jnHRZken)S+Co#gz zoVw)Q0#~-Ax4n@2Rot5y?*no%q6aoHqddoh|x0#%}nGhGt{>1lcv?Bj$KMER+rh_nh2Pw z*0apip+jccJYpB2T=xNTs5=qtB_)WL@d?S8Ar2rpRY#AYlF`XaB8^Sx4g5d#u8E=y~HyYw1!fb;MXc zE}o9~&CW=vL5k|yRp8pozmB1#0Vu zxm;W_4vSg8Gt;Y>zAiI;d#TXGdvsMHibyTiqF|+IC4ylS6fyx;AaZ?&y2Y0VhQOcZ z0&_kySJRBlqTp6@?c0y)HoaelothP!&2-IKvDAuE!%^%!T@ zzPZd@Yn8{WdcXNxe$-~@HRDUWK?*bVcVqb}W_sR>W@pW7GT4aWA0~xaV2Nw9Q%$SG z9&2acSdZ9aJ!)oV7N}SL!B{iZEcTjCJz8p#(cbf#`j4FjuE+*q)8N;XKMO+EcB-EY zce#wR+BX*%ceE{t7^}J#7)uZM%*>oO7nsJXHcck{X6l}tA!%`|=6xw<8q?>zsTNb# zwC3c@)G=e(`KDF-rkQIutu}M*F^!Ysp+2Bo`&s7XHZ!GsX6nd9<4cF>f%@ttH0x(r zna}vP)Vxz*_-kK`XKIG)MvXDGCBtP zm_qe@Om}4>8811^(9*+nr#?leh7ayk$q=1dK1F%x5U?Ij1!J5FtS!cv%fXV`v&@Pe zDn$mfNM8D%0<@v{Ojj+47Gwv9|mdExrn1fF0i8yIXETwvkS+MwHVYn<8~xK@fEU;d^c%g?pTuOFg3T}(@IXGDZn zx*7qQybE;B0&qh&A`Llz$MyGbh`S%{@0-&F_F#U#m-*86dK?J9C#hga_97hoqWU}UNHO54R ze!TP-V|6@Or{XV&_`n1}+#&MngJZHl$+Ey$oq*(IW((cft-k;FT+Xy+2kSN7o(sz* z|De@0B;sDAW?Zbt^;bP^!3!zcAQ-z>-hi=>Nzcoq=W931DCQ4|us45IW8`u3aTD^> zN9SX%2y7Ye9ucn6gYjnoKBvcMG(-kD7Hr41m?-G2d24EAmEV;(VN117PqC)M z8kreKm6nq}X@+(u&Q$LqrVK1&JlNV&O)VWZ?bcezGt5KJ$x1#{zuZ)TWZ+BcMSIs;-`-o6q>x0&3 z#yjr#`tI+m58Xu9xAI@qr^nNv5v#y#tn;K+j`X{dk>2RY(!#_g;LJ#5VdU zo2APc?+bDnD7gjHcTr;dCAV_5PgZcI5ow3PV;?`TtSv=Ib z{OlPS&oC&kAG#Y$<&0%4)q+@N0-DKom3m%;s0vqiRv`bYK2gN#pbj&%#kluPd4agr z5KrG2TsSimM1G=wTamQ3FP|8*kSsdPy>FS5+vA}l%SXpDo^diSp)Mq^1MsW@HS=!} zyY$VpugvuPQuGIeky@!pdQ)p!6NMxm-7F*$)#3%}S6QB7nYjg#EuITuw6-L{BC2*4 z(E&4+WfA>-;_^BKI2lRo0+%a$ifO&5emTl0HvFyN0;MI0RW23z=k@*+Tn# zWV~i%#331V-TJ|E5EY%O-ArHMvpJb*P4mSq(-*Ib`I5e9RbkToctOVnt$99|rw;`& z>p)akGFn!yj`7UU#ULEMSk)|Fa=a<>eTuWt0QVe+oS1dFpwQv zk#qE?M}ljpCu))EEFCkoa=hs>YEYKO`y-?FXnl!AGn+*dRadbF(3eIE&nZ(4AJ{ys z%+dWx9W#L9g9aUWwF#768bEF8SC^{)*sm_lAeVuQu2Ox9?)5J^Q_VY~7t!s% zw-=GAZVV5eFRI!2=Ry~}NF-^FMqmbqWiCDxcIx z-ghk@qsjZ0KJvb-$lM6V%io%8&?fco+N8e6%v@O@CJ9ePE?b(nM+{f(@8oh>ue#$L z!T2K(JR#z!l1GhYku_6N-(w}jty2;g#WQsUwQkHGP(ryxAc1cjiMc!IU)u$|X;QJM(^*in8QUT znAYVE7wIume};>Eh(7uNV=}EC=%dO_hLfBiJn1GXiS$>H4w=@~PXEz$r>vRM@m>0# zxX{d8QDEj+Ozl3?z1wuZXu4VQZ=jPqeV2}#p>15+L|l4G8~YX^=G#(gotPUM#N4p3 zk0D(*r10071}D@j@586US8D?V=om1qZsZz>e!aRLuf%%Ox~TmFkP-tYwNCk&+&AZv zQ|wH2s)|fz)s(N1o*ZX+Km13bE7zL#_Hs2J#vXi+6rj2~^(Dz^O<5!fR;@3dx$qw{ z`)25_(xnD6Ez$;pMDxqZh1tT2m)G1CbR|wy--0Zfp%tY|i$To39GAnP5?<4KHG8RP zy&%;$s2&VOX!f~8M5tVYP)A^~T?M2DYZMJYt+(e&e*Lm6!c!0b-R@VtdgoNhpmjm5 zeP7$5Zp4PR9%?rr=uS(-+xKN<$19=>FIxQ!bji|FS6mHB?s*nh+F$u z_!V0bCCnO3(9@wKPiTvR+f1`S(=!6;8D(6``B%xmF#k;c)sgW|oslJ+o>9-ghL#x% zu^XBY5GF*+*<`v-XYyeB(J7f(J?YuwKghp#Z;x5~R6UD;8R^sKwT{+r7#wJm4+x#g zcu&){Vimd52j@x;i)WB_vGJrM^f?lUXYMMC!Jjj?(C->%IYQqf;dtf-Gm`cMh=3K(~MS;o+{L<5@KZ}@r#7y7aAk-zEUK)s}@20+6!w{Xi zc>30Q-Exh~u5uU+OC$XYTCZ+de<|#TeP&_sQ^pDO95IfeVHrGFu}^*fWZ)s=s`j-A zc&kfWssmig7Nn~gP<18OFjupsn*LYUw^TPsuTMtg)$*^6;IM(~FkjN>{0^9G1qK0i z|53=r@x1fP2Z!RFsZTThjQ7{a>GULRl%&D(!Pj)IA>@M*;@I%2lfF%5od}0q=+Gek zjorYp(WEx6ksOIn#VzJB6ImRqawP%Fmyx-doOBD9SQIyy~XlZxX(ZjsA*#lMQpKiYsk;#6Cl202{S72N7Emy9@kaldjs!v`~C+UUBlF^X) z;F|)O>UtSC9o6EoSN+LOHJwzk@B_s?c50=QT4twivQtF?ml{g#)bHD=qDD)q27p)H zZ>Rd~)a`n3-9IIhGlrPXcXl73uKb-Xg950rrsZ=+hVIgpE4hGo_TbFM$Oq=+u5R&9 z>$R(8XiNmwQ8gCH$hHtXtb4Ls{WvH+8fYOnt_)K+%(lv?ZBYO9cJT(M_^rA)RxPPP zBliFsg_v~i>cJ``1}5rx6*WDUj{5RRH5s#~CLQ;Qy!2gB;nM|bL4O;Ioi>JlOdG;3 z{EmWfR|9o?&8|Z{6bEGq!p~-E5ccERC=7l>;@W$^?ZdU*>Z_A*)%I=?OUgpsiS6oM zl0+J)bSO!Fw0-M00q08loX+Lb~?o9GSWJHiZXhi}z1z{kuQnegs zOm@^=BlN>aU4BNHx`9**z41Q+CwI8FQ+ikK^zM&mNbfX_>Fbz-;~DSIrO1GO3BIW( zoD%ke>hG7v6WTdJ2E%;(?$o|HH=X%du8R(u^PW`1m)pR5(Fn03OMQB38nDNXdmSz) zo|mZDPw!eNok?7?=B_(kiP_+GY8$FlxHMOC$NmC5sX3#`micBZ6iaM59&GfG%+-mw zFj7fk3WRcmb0t$K!D1*&se;5=sUwBS`YqLWy3o>5c&{_`AFilxMi)8Zc}+BZYaH`)LmFx&CrqLh&6ZL>B5qk{n-Vr*&hpS8A6t~ePpn_ zTB|E=eVW0=5Pc`N$3m@fV_Fv@E=3}1TgH6CBJc7G1N+d-6d{29IX1aFZap8L+QTc#Ih{aX1oW) zo{)BnylSQ=>g6|5rX`@R#9*RbWAV%*LFp5oT}%|WVxm}Drp*)@-$X{~@B8CYt2Vaj zzPHL_^H!rtkE!Z>qxnmuWUee%i?mFu$6#k_OSWSv(zMN)L*qL~Qz*h#$9XK7+#H*1LtK%Z0U@k^Ajczz;`a!7a)wP)!ftWL2wV7%^_kNudI|KItxfdCzJOfw06w zB{%XfED!X>mX*x(uh!^N-Y4FHNTjP1a9<(0RB#yl9=K?y*+W>w&xt2M(%AISaT#@KTGun;Pb+s7kCgLRMT8xz0OxTr3nM@NFrMu~C zKU*8X*TjGZJ+-!J8Bs{rlQ^ntDqe1CO$>{tuU(kEoYIi5tC^gunVf2-q8d4P29t!~ zp3wq)`1nbwO(V~akETm&(g_Qh6YrPt7JTc}um4|lda({9TQj_vwS7)$NyS*@Rw%RuX2K%Mut zc=B7N$#T)s=l@Z6Lt^W6npz;;u;JLxyDNIdhf(zl8CPQFKbJK{$ea!qAzw~M))Zv> z50;N*T?DN)a{CPUNJ zvp)q!eTtOvG}g6QeygkdTPF?y2VyJmOU6Qb65~;%FjXQ9{7x+;Ym3{=VQzUXnH^F9 z>92Pg>)<2s9lG8bWc?TQ+5=3xoZ&m;V`wpJtBmf@PX>;zPY%)xL%oj`)08+SN2+}e z@H;%l*EjbKk##-dS4S{Ch4)Vca6_0(7#7?*K<-knu)fXIYSYy+y*}wr-RwUxHPi30 zru!#NADcWi+|(PLpe7Sk+Ul0p^OK@d=SOB8J;WY*s3KjzerxAMDm(yJX=+>7L@a)a=C~RJz{lclMYxUVsZh=i5uco)eDoO!^YFQ)x(IP;--8tZe0z{z8a{X zkYI{t2tlt4w_FkfaH00ZI5VA+iHKP)vk@cdNHcBOGlKeAT{-!sRL7lW8fnj!F3qlE z1Our0N8}c5G`x$sgT2H`!|UEMLr0h1VrG`p)Q1>^9Q*7aGH^O=pY0b1V-i?|aWjs4 zPAs-={DcF{oOy9@uMo`iQootHyHxuePYJi26WS6D35k!cW8S0db~>u%b~TlyA^io; zizGyX2*x~9?(e(ATiNE$2pDwd;)vCa&(k)b#H-4a{z&R*0d6Rf{gV*0U8ZAOFq+m1 zQttXoE(hyefgv*KP5q-Fagu3EmeaDEiAsG^h^TQrbAv(wMsDVbPg9Ad_D;ofGN0+u?ku)!uAQX5PPQB7bJI~ zoqL+DKs%x=?b&f)k_g%&S`7O?kcdg_EiU?vYotA4ce1<^x2YF!BQfwB9R{YuO;jaI zl+n(_9PW=>1P`UBC(O+B{Gxxr9^^v<7X2WWI8zT2*-LDO4APdb?LmsygF!kXcN%Nf z0KK5nnOK{Tq09&pBEFBRr8mQBG7(SKE#b}mBFO1#!aCho)|VzP(M%ZGbGw=&0*KXt z7}YA3UW?w*)=`1iwSVm*tp`BUuBM&S@@lPqWrCWd7=z3k3xjOVofE^F|E0E@y3x?WIQ8qlPsMO$wYGEI-W_6 zd^oQ0bYb^HLcCMYNhe)NA8WU}nUuIS6EZ9_QXpujr-IJP#Kh95d3rvytfI-V9tCU+ z>{^PtP;#f|CwKu6nAaQF2;?YWxLE+20 zDdx+S%%#|RTae%ICtFehjmf=kzc&3{%=>jfFqZ(Y3G$%WG|Z|2l0_V+%k+Z+wkcE> z@kkME4G1&Xavhuav9=8;n2!2A%IH^%Nb@IVM-%hJNY%@I_Y0Dsm)D=gfD1R3{?%Ec zNNqJ6+prl-CTIm8Q_R{W@h5SsLp}Okksqhm#od1~Cuh%whOqh?JIn&On7!f>U(odL z-=%%O${A4eGvYQv(uC$>w5U#9368jX%*jL^cO-*mD7zfeb~tfzU*6~Y^1gdFVgbFVZpSr8a%ZM zn~+-j9gL-5!Q@xY1{(x4&jXq)$n0PSxHhHLCY2{fT86QBegh$4oPT4{tbRcFmT6A@ zi|{ei^p!xgb@uIvgMMgJ1Fe6>ue z%yGRvhC+4Tjw05fAwK5F{^Z@9)9)k=BhSfI!JSqR1IY8Q*9%c^eo&Fy`2j}GH;CJ-j zH0)_O_U%E_5O${FbbA_D`>-jo06c*uNF1jA@r%5GHDentnar84C)(O`hu6mG~vJ+CreD{nq8&N%r)=m-;jdbgYz0}WyUaT6Qiu&$Qv*|_XIPpr0G+_#)R!d~W`N6n#II!>r@q9jtmpb& zuHmMfxXRoN$mTfz^DBqrl&jNpaXml>fC9g~+XerqZQ5DQ&IZ%EyEI#cJkA<`2Nhvf z+nVV2UahCn0sP2OF>LQuf_E^mWIN#Zt7S;QcD0Y{YWp0g1LQ~BZlJfrO#C9*vG-(( z5AUEF91vz^CX`~2`l=KMd5Cw|53qU#PatZ|FEjJ+vZI51_2dV9V2of2Q!&4LKBdG~ zq3vz6OkrokDZN2T+vq!>AI#52K?ZduD+FjD*+b%Jqcu_48TK(J_H3lD_S5K%(kLdu z^wj~urIx#cW_nDE#E6yLz$^7f%pl?)U@Z)RQ){No_&s_bvP|+sMmv|fw|FZ_Dp2Qn zNl%{|7N=nPQCo}XGB`<^M@`ZB?3kBR=E?R%ZxCrOY$ z^>>j+2dry{jvZ7Bn3zqHDed0q0ut&UDE}CFVI1H_Yob9t&f?hUAxCD`N^L41Zd=M{ zVlfXBaW*}`Gg~NTmh&9uIm~k%&viUE@Z4a!kCC+4bhne*LkM?4@@eeS0{5(6)yd+c zLB~?9Jc263gQ6Oh3U-cAU$DDWIvC)ZMi9mW9H97!j>kk3IzesL7_`{0EN(279cEff zO07?d;yNZXcNz53dO_?l(2Aea8T6Q@A4%V?fEfXY?Y*A* z0;B0`BuRqxceCv%R*S91Gh@xRw~V%&5A3T9w-A98*(jiFxh{AM!Fr!}WzU!8O4Xg# z-^r$Kf?SE+LQ1ZE!?lJsHj|lR0t<@V;vybIbPf4Uzo{k6aY&+x|)h6qufmsjB7MnahUla^DwtxXpJ5k*) zvtTXst2x|6tsZy+%i#m2o=2yDAU7_IqvM{eXAbr~|xk z(}nd$lgK6?54;OB@cO|9$JAikX@l)t>OBr@+XQUdvGY-=MX~=423yqHwaG<~HP}RQ z@$>MnA%}FfLcnKR75aFFUM@E6I|mn;J$dnr_bb1YSnV0U2(jYUgRO^xVp8Z5(o|xG z_KVcfYA-DOjYoV-UcTIQUqShqZuHSdx^!k)v}%^bh@BhOrq{$k*j_#7(g2F}}jxB^3Xp-2b z?!nP;n+e;0uZ>nJo;L}EiZzPX5XFaQbrS}*3hnJhv^F)<65DNNMZwBK>&W}_h!)>% z)ixmToU%{Wu#7PEhOck8Xs$h1avzM?8F9d>?dCFFE(l(>%eu2y; zGTIpF^CB>3n^@T6MMq5$t zfyPet6Ioamz_I|A1+XlDmAT0;>dQQ&q?N&NjZmzW;=I?-Mg9fl80%? z6c{AF7TF+Ut7$%xxZJ9#7pTmJ=7oBU2jW8eKCU`|E7e&wOdPZ^S5iZj-QzX6++w<0 z39<&DZRRQa%t?EVCZVJFah6}izHUI+zI>#)p%1(Q$puKY8j>pok_0^LVhTEkYiOcQ zY*RM@1cyiV0kji{M_s1ATR*p{V;g&=Ky;vz&;s~r{_6= zbyXG6F2cGb;IFF6&IKYOzYqrjNs}wV$(C zy?-F?-fK2?#V75JHFjKKjr9xV5y1dT)Eg~u8woscTsO+ZnUmV$?yh(RZEd}_yOeh5 z!hpX83yg_yHfcXpd^YSW={MWj{0rW1%jJ><9cJ5BfA`l|J$+-(ctdP&6tbI-6_QHT zY0?(cXj4iXPMUkGCt0NG4s;F3z++$M{^xID13RD={u22~2A(ce5=4M8d8z6I9FX!4 zxTveacXiqy$lRs&V=`twuTtkyk($R3pe`ck=cr8GDNQ_y=S%%uey)@Ty41DbCiSH^ zw3*tgo+mCwT`0M~Ql#sWjais?H;S63DyR{t2whcwAox!kf6EvS&(D!x9mAObuYitr zr=GC$4$=e5?ZFZP!$6FtPjd}l&>L>S<)%Kz!@2`j@fY@^oE}AFnnVKLtt&dcjU@5F zm`nbuv9b84TvR=sWq>0$tJ6E#dXVf)mKwju|mwMXH3qp-jKYNJUs%VWh ztv>s(TuW7qD+>(O!}6)W?$py+0|aSc4xUXG=d~28*hg5xC+H1w*mx#q8F!5%h{N5`c0qh~ zl=KikHCDa%lzte2GUX;DPFx z#yqJpPlT0k$#a2zPMk{%6`0Sx<0S|XO9m!%?@eSd)85;;$fI0&T+U^SH^Og$?tmaL z>XS?f$S|>h#4|0y+X6VjAY(@<%OCif_^e8SPS#2jl+Coc4 zMRqLX&Kj3piRSwUPHBDrKu)h}^nfAkaoRN)L(Vg;_c&z16zAYx^o$tWAT!k-RY!D} zRpSXR=slomc+DwWBkv!Ky1SyyGdzhgacj5UnfN;s*?R0a!A5P<8PXh}TKnEDx8D>SwbxR5C~N;R{ifTKqxR$C zH@<5fOots}(>sq_0GXT8I;_BzD4WtStk9J>ead3Foa}x4=m)vf zk-+kx32l`BC}VuDZRyyk<^9#JLRTc!RS->kALlkZoU|Wu!+{484$86i)>sEq{}{e9 zjCTtI20eH$%BHqWe;BcJ6y*vjw}R|wcPooG2nElW$Bgert$iDUJcQIrT_|edsq=pC z89}i_A9i}b$(?kg)B6y23`3Sw6Su~uH^(lWNTzo>y({`(-NJ3B_f~#~k(W%T7^w;> zphE?F%(gcI=BPc|6UD0uM(P8p5HD>YIPB74M)P4FE${i1e&SH7%h%~Wjax)}SK2#) zyGU)2o$-k+ka*bX*2cuu(Y>$C(v8F^=y}`z9IIwi>FDCYn>k3`xZnmvMo;5!CcAF z@5$`_>WFj)s#S+y54j^((kIdimU3tM>UNp!<8Dfg9aXq7J#I^xA z!t>!Lj(tm7v-G=PN^2E4@$%DT14KGka+lK{%D*I0?ZP42+afO(4{mQdC3BsrT;a-} z=@zdi4uGDN&M~dG!8cIY`@s`H@>dsp_q9)beKO<3Iky}aFHs9MLYP6u8M)reUQ74@=Q{9g%eLd-7-q^B zR5)klrck3BaUxaT`>2WtTs#%t7~4qYS|!&`?-wa9e~#^p$c3K-!(vEX`*tg2%sS|x z=_hHA+4fl5cb>gb2%l=D6|v3M_Cz-95%KH%J|{x#P8 zQr=L{RMWE4Gnqs3x?g+DV-9`HD0wBgqoK)7K4o`N#n-Mm7F9E(o#5A z;^r3Jr8xEXf`l()y45C@jvSw|2Vik>iolHd>VD{zKHI%?`5dW%VPCS*mgaoPawfZ*9A@VY4oyU?qngjjIZXUFYU9+6eC3o4y<}qD@-@YmV6p=B6W z8QRnQ4t=hfnMPlo?^EkQeD2i=|1AW4fUPWZ>I195z|52uF0u{QEdv{tE2#uSu($Y# z5M9!33rD)zL1i25vez9~_5*>>5M>2-TV4crze>=~fInSlpTF1+a$0kjoDD+&-a)}G z?QghP{Usw)w-7qLQ$2JGLlVJHn+eCp#nJSFn)PFm0nGHpTc-O8RB9oD=SUe;x^N3& zRrWYwbV!Y|bwQ6PFSFV$9ux=k2oaI7tklY&&gamCM_&Z zvOlFv+AQBFh#*~nSAx;RAEPF2blj1PWk6#3t%GwTFUQj+TNuL#6m@WOO3MGD&b@+c1M7SnZ}*UO3a%eF z@77&K65-HI+{xt3{G9c78;>(%|C9bTp!%#g8zJ28w$NhFDsO19Z`CmLxEDlz87#m% zb326Yux>mX912=aMw~S>pL*btTu$$?VKR^Qc6bt#aKDdCy-xhovrT8OpHk>rci-8M zazVh4Skpe(uhP>zy&b;9$Ov(@sdi6#ny(?6i&a<<_=|zN?JJ~=Nq+*|4@q>eV-X5{)KG^>j{lJU>(BqRa5pXD9488~AfVF7; zeQ`}d0#$0eih~^19=W?p=pvTQuWI5Vr-rR73=-k)(2{sw>5l2!yeNy(; zSmShmrZyJ?Fg~jryi1#z2`$l3BIH?hrCfZgr^l=!3rDKip7C&Pn zUVF3vqTY$JStt|MAS7$>{$hzj+Z#(42!Il!BbEtZh&e1OAZRdVpXG5peH{RcuyDKe zOq6|Oq1K_alJuQdi)GsHxZ&wYr)Q8%=-I6S~?LN$tqR8?W`(Set9Cx2+d4 z(|~``n#{?}Z^rY$<)L_~XVoaV_>B7>p%7MxmuszU5o_NSnWBjjl`|${MLbmnt4`zU ztBQD5mqbJ7uk=SlcY0QjtO;$7T5ri&H5{pxY8xARVF}t#dmKx8Kn|0^yRkAz1oyS& z0+q>(LgVYRL?-_!2^qsNMV8=OHFBxYqJ^;Ov$8vq}4&qH+mz=#8VC8V)+hSIA zPerdjHz#U^0B4Pu-1lgpUrS*8nMDta)KOg;4fU*?Xtt>UH>*!-&N1eQ^_~&!l(AVy zbe$~mQ88;jt2~lxztVX2zSD(7Of>5+C`GBzETagUvM zzmnYP>IpW{yW;qa@yQ2j<^O{bs~XzJJ|r@;g50rG2j>9GQ?MrVqR|`zaJen|guAdT ziZDE@QfS9D2tzU{I5@?*Ydz1z1(*gV@a{_HB&iRotK+VQ*|`<}f;~Ie;olO!*6Rqb zhcxDSC;bpvMem0&;?^95dhh8ku&><@_HtqX(`@_s!2xme$8h(Hn?HiPKa86{Ca-bx zM{xItar4J;_qVK}W|A66f`_h=rNHB2V@z7!nCZ2WLPL*#N*rCI&=`n;tC`95+c2W} zTz|;(T&~X;PuHyG+8MK^g@r{kl4)$ss(lF43FlV+TyH!z({rASStr=SKxfTvksfj- z$G(OfVAUEDdOBK(yuSGm?IL@A1O^j-a6Am|+5i6$3?4pLATk&LdSF(~9Ri4c0GOQn z6%NGQSNLk((|iExX5PO!6kyDB?K2v#8Z6Ytk)YtpaqxNRtNrl#GYU~Zd>q=gGU#WM z7v|e3&pjwU?Fc7r9qea^O;t7{ud*3=EBpgwhHtVfuG;s{^GOb!cf!BOm#OpEc~f8T zaZrS;5?3vYi`$^lbUvzyb&a&en%u|wjk9VIsqvv&LPI*V5% zmVq^jNmBmbD{_nUL=S^*X}Lub=!x`BI`x00NBfoZi7Nk{9_?2SbO!cFy2EL21xE8e zt&53-2oDxBY2LOh4z4lkR%|e4sJ?#bDAgdhmRYakg43LvI#UwT_4WO3uYo!b8^h#` zR?cRrPhO-Z>B4oy)9g!}Wimr%=okmAVXQ_}KPh`y74}soQi&ET)hAItkTJARN>oJ= zO&z&I(stWvViM{1Lm+*tr{zVuUbAuMjH-a7f6Gpn0(xJA!~i3=FGPM{Y+G+Ibu(My z!bhYBB;D%s`MRumm1>?-ftoEh)?6IdyK#+M>~$7Jw5x%NZhHAPqW}9LA^Z?t}W#(BF?Os1m~XI>Wz*RH5{TMLuwKhTqnY^ip+-QZK`m zF3NFpJSU z57DL+4CL6EBngXwzYwoKa38nK$s`S!E))gCk6~4ja^u^r`8l(^-M=AlQOmQEHw!Cs z^x*QZU{MR*Z2J`{d3($3pr461*H&r8{2Dgmdy=!QNMMTA%SU=0wS0M)K<09(2qT7A)kit0PO0C?^=K7{b?c1V)#3{Tkl5;BEo3)6M+k+m| z@&NBwty+7T#sS7K4f9H5J^urIb?Es(J$CXxH*#Blk1FH?nvl}aqk?4prN9Ldy(r|zUxu}OD>)70l~sI*RQ&Z%fwm?)hS;Z$N_ewfDKU)mtm0?MpR_mx{v~zX8Wt& z+Stb@^Ki`+f0Mqca!PT&+JB07Fqb$JxA%KE)vPY{4lfw(=uYn({FX8dywt;$kFh(^ z02=;`U&$j zT4JsUW3Es;Ik-@WaAWlZ;f!G`>hq8hW-Mc9ylMiKMbn-_?Q5{@vk@Uf2XqbU{^N>= zR{A`vJZXMyIBP<=gHCkInBtKyBHB|_jT-;9jsWWk3>)QXHnb&%y* zJ|k1K{ffr1V`A=oX6U6QzDTaECe*b=iE-h?NG6u!c*bq4&{C(@geqkJrcwzQJ(f0O+S%-HOBn$%tiO41r|$u6}h;37p4u?u5GXq4=kB1`6Ibj1kj-xh+q=i|5k2WO{inZ ze*p_4`hwM-EtEaH>=+QENT~=da38Fte7ZsA%jO@P<0Qd%rTyn7*IMriw5|8B{#4{@ z8&`Nx#S^1cMQ;uOjvb!GhWsK7)o8i{$`Nn8+j)PYeqW^D?+#bqt2(%AksU`pE$>~ynh!@Bhv`=KD3VI$0(Z4ri?ztHy}5h zYiD(3=VJy=oD#EY%fJYuX;eN-q0TZoJCzy>up(M>$UraOVbXLRf8wUL@p4Q*yVSRC z0S)n!JL7-39nbc`=As8=~)hW5H!NQ*UIU&_plQZ@Q;k0Q4~U^k5? zFN{^)Q)V>%hZK~vhJ|&Id#qF;9aIlVHP#+&x!a}ArqOJblo4XqoA_K`%~>QltV4Y@ zC#FZ%4GVgD51g{~{e!tS>!=8#?3$Ndz07ExOlG}IW&`WbIjy-vZJY-se^P#aEoZxv^)xp|{%ee?IL$yyc%y`%K(2jx$tFm$($iS@LH25=qRuvP^AbviabX*|@9}Yp`?0t^0zuAr#5s zC&4bs3P)qV9prtFY_gr8tpN80#cgFa&MUI+@>%DrdvT7hyDxY|65Sor%Hz6~-7Wf@ z9HP4J)9uPB_NGW?VHiQBc+rHrBTW;=jWDggfu<)G@JFR0{9JuzVcCB2|8iWP|F_2F z89Xk(J+2=kNBrLy*Oq@euJ9a!H2S6q6YBv?tYt!wEN|fSOy3}Jd%e-3C9p!m+UU@dY)Ji(18)-Ao1Dm+=EDyD?^6?!)fc z%BGAB`H^ob%#ZwW?)thiVB`-=j#Wi2!>8LI;coCXoIVY`>g|!-=4j}q^@&AT)gSI&f{L)N`C;hNQle?#3Y~!VJDo7u|{Saor_<2(k(>LZ$tNBVrXHdTf@$z z3lpcDj6woNx{2*3|UZ}-jTJ}=G%VnQl^Bbv)l__GS4Jm=E7+Khy4|FL1 zTOh^U?6%?b1jaWdyB=7=Y_qA63R! z#+@mdy%O4#;d$w+#N()%7PK4HD79jJQrE~0hpa6$(`K0}(=YG6S`?t;=-p3(E0_#O z9zvOryq)*uN#5eP^_w2XBzm3oQy;J8^N{H|k3sSHJfO_}Vn`hn?@=h7rg-W+LCob<$4^#r%p;uT70eP>uJ?WqqTlwXnp zsntFv&wK1{j*U7e);JUKM-Gks3M5SVSyF5*oXM-2XO> z{kBy7Q>jsKAu&~bN7oLGeOTWNqOt#TYCnx_Bf4K`Y={cFPvA%7s>QWJWFZTDyg+sO z^ZhWI(|v??^~Vs}n=JDh+f{A+Q&6c<8qE#ThzPkUV+d;8Tn-1 zKtkIRs_8OP5?dOzZdxDDoI3Rjxtx&1?NMZp8`+b$Mm{K|i6n%ug^%n!aE>%2)RZk^ zqW#rcSK_&v)8Y&zAO`Ri23@KNu>KY@HA0D22wi=Pd%mGpDRh(mm{hsvJre5Q&SMV`j~L#Cr0#J@>cc)wQYS}pJ7THl z(S858`nS9esMlD3LN+)apWhIDF`AdLhO%?kH6NiznyLz^W{p^L9y^YrYVrw175GwK zD5@s1LQ(hhQ&jEVS1qX8Q7H6{_zZB$pW4G(<)}0a9(elqX_z|RDsg^~cNW9=k8^&D zqfMOO$7S4;cYfok690Gq@*0$JkONIT>VX)6J)FMDj@gkWe!=vNAZ(_~xVID{AL$() zPRs%ig?Rs-k_pQ--E2{zgF-ipQ$jZSp|L=kZJJ)=lU#5D%m}H~B1>7)6I}uqQUlfLVl@~- zGxr6BovGh3V}{>;IDVM}osg|#7^zQC6NG1lBUIfNlzFrz6YR5#d3!WY&6?&Lf{&g9$y;1s3FuY11Bv>pr!vxA}4%TFD#N60{C#_ptm zEi5UOeSSE>PMClIUUXhj;{*!1j?g1o6Ep73YW?PsV5u}gB&`fKA9I6prPK_;u#fQO zMZqo@bEWQ=_rm5pV=l{M8e6-YH&B;olh$t@%mca0$4Hxf4DeL`X_1o5H{;$7+>-i0!u3$=%lYH?p^?9l>6CMw3sl=GkfQKsWHgCpdJo_Hp&PP!S%J@1lV3L1+!CLf9cfE1#pVQ%0(u zLpr4o;b!;N>v-{TplCFBq)C)mqEkrB-q2&HEvl>6kH$Sc}U$)`8<$}a?gdh#DHF?_GfW`$jv6aZjWcaXbtghV z%C7oN_6nGpK1j{?sBWFo52?fR`ydsQ76n?v6QjiTPkhN14#YIAzeIXHL4lha547A1 z;M|^s5oz)S{~gF-K(Eh(k0aUgK9S?`3yl}e29sQujbf_lB;aPiJ@SE}o3LQ6k-aVx zBO3@6S(923b|pV;OZ$m)tHyDH^6FB9lXusyZjcCwtUFpYJW*n~C$&vEgXbk9d#i(l z^Q4&Q-szqN_Jnn#vU zHO3^_=s{Gf96e$E4&h1NhdH2oBB}J~v?$RfoDPdpC8BmTG=mana7WZhSr!98hofOn z-H-2FMC#PtMXqE>_gPf*C7f+`Yk>7(s8XZ?zJZWDO@p9sRK~r(q!=SZW&aU(j`p(< zSh$ybZtd!T41L*WZQ*;NkE&|b>(Kf*9uxNq3C@POPk*B~ZtW7CTf`c8=%du6zu>J^ z@ODx}G9iOVgjyQIf4dly`(?t&B{$_YXQl#DBsb+Dn&lK&*QA?38i!RQ$te%|v|eW7 zXRouvFeTnnLNRsBCA&uIqBdXt_}Ewbv&e*uyK^)Es7R0$*BTiy;v}#mhMDOr`(cH^q;S~W{&g8D@ z4xiEV2X0IhVjPseUnI>Orxy=$Oy>1sQJH=$HQ2UgqxqY5#Q~#fBYmX7Buw7Hv)yVx zh7zz!qZ-lN(lGwJ#<@Q7_~Pz%IF7{E58!YN#>`7dlJWd|1Br&ZjLdK;!bx)3@9Qo8*micSLwi8sPR1f#lmHc0^o#0Q za#k%0)+GUF*gmBNuqST;;_fAlYwxzv^BRJV%j1oUHG!*D5kzS4laGGb_<2Cr>fq;Q z!OuOUAl!(x4wMo6>>|a+Pi%OIgSnF2ZF&5Z-2M2u8T^#ol(+G7JNPM0*!U@;JfyFJ60ITLTYok@4Hp{v!G_$KFBB?@we#jj-f6_fWKSW{&WO)dY^ok@6{zlm* zoeMbfwIIQX0d5Zc4c((P6}hP3X*B(7t*B^4CeDMPrWyyak6R0oIMI022qFDeIAHP} znpR$$7M~wR39UEzYRv|nFx}MX#U8t`CiP&J8Ml^Gfk-cKu8WYaRV##F0y)()`i9`R zpUI6?7a)MIOcrf}3cMgqAJW7;UbVVDF`?5|I9bUqwMysbK)STONl z6Qp+sq%bIM)8FjvV!PF)!<6m}hpC8M_vx;~bwx9BC5$HuRPaUVja@U}dBQr|?CQV+f)u)-{1aT8B3)JqnhfjJ?@_l()a{UM@=jRlJb z2-14rai2>o&!PrRwxEnGuNg%Rhrdvt$F8wi53zyaDEx`ayn(td;>QN z1?&s0=_^1J!6J_2?L(OD>cV2C?>Q)|Mu4aF4G8d4xfy@}i`7JA5eEUn8Ue>c(6SGOvkHWCF*v}s^7|p&c_6zFgbT~ko=ijLyC<+0sdQUm|p=Kk1J(j)-xP zek{#*0n%o9$E8S6BA&(?`SSZL-5~F<^iCrb7%Ck0b+6|&Maw1j%Axav1`waz#U2UM z4!&}?OM6lURVS~LGVCYhcnQr$K3Yy&OOCGm?{tB@0ACP>;ORc)6b=%FAL^k+S5lPPZ%@DHPI$k{7aS31!AeY%3aCvY9f>e%$Fis{;*4nEhEp4ZT(5_%Z^w_YOOYPHFU^2z>Zy? zIt1-buUG+sK_pS(WcziLg_^gW#)H1WoT$9UdR-#d8ntgyL!HeRbqyVVDPN9P~) z(JGGY(zV)EWO;C^h-{D<5Mhz{&QU0567umE-e=LyzOSV;6B4wBk;I`6c;2w)3ZtRF z!R}%PtU|x5S+@=7bjrtPb{fZoYIbm5&sQTsNNsA=J8yS=FjZevt#vWd_23 z?b||A*|)a==ii>ij*YP?c!<8#$hOb}IzsSup|vaIr$HvuRK+qnq4j`8^LAQh^Jr$7 zDeNBPyv&str}jg~Z4aPT2nJf0rQQ(-;IExz9Du*z)>^Sb{fMhWoYXhDXPQy}kqB+D z5U+=07o)K-75ya#n;%qN?Mqx{HX=Ia-GYdnTj%F;eKH-?hYf++L1=GScH|eQuIzAb zTB%eFy!y(Z%EiQwN2WgoS!Xt~PDb3~WC%#4D~S6%Q;Nx4%BiKe8`t-jv4w9Dyrs(` zHVK)L>8*@QocE=GJs!d^VSG_`Ly2t?*@0Ts?f4NiTh=Sc@GnK)ebTlhm(e$N724{q zQ)IiELIKX!i%%vZh3ci3jDTJe@*ZapkJ50&{_b?0dW3FT;?|48>%zQ|!;G-FvRly! znc!g;4+qgWS8Z+H%J$JNne#B=wMNq#3S_3U%X%2!^N<46VH^TGxM-mAG_qD(b%tgL^w2%#nYtX)Wy^Q>Co*`WigCJ})m!Yl0kMRkBQ z&VlOBw4a2mzyI0dSymQ70(nBoP{TI0w0%wRRY>JPHxr%HA3S(hhr5c(UUR`8D-KtE z(zst7Yo>KMqTz}n^~G&M1PB0eAJJ*x#6lfTavLwA)}@4#yA8$6#Od=V}+|adsQ8~0U9wFeqU6c0hF4g zFWX5rnQhV!Hl@y(X#FLHUtrI`=}>0~_vyLkAtPf$=dFB#;CaoF1nAOF2igSJzex-_ z0?&V3DFuEFWHYggBRe1Y)U>JG5TPFJp-y|ONE4u%cs>Hyp|?58X!GQ~CF*fXYqc_Lc`ECZ(E9y4GzC!QIVov|XoWpMMKWMFcU z{W~6NJ?*vzff3XALA|3b8UE(->S+L(WF)AejF>Z&+pQcaT2qnOD783`^rru;4uCD-nI1i-e%pl z5!sLv@OlH zmih7o1Y_Xd<+|$l<9)V|L95{BI9J1z-g1~cFoxy)C{tjZa`>0Dqe9|JY5sM52mju{ z^9$E%`>y1A?xC9RP)zG}Q`2>JP1j3JK5C*4>dH?QzNlYCKhzcVtLI{=2XM-uo-^%w z&XRh1MY4EgJs-;8k{!B4*Q4Pi>F4P+I+a05)M~B5{f|*A)Q!~o9?$9zdROjb)#w?4 zn|?`MaXd8byM{V7dZ%K&DU-05#3RK%5QtUq0(HP=SdKsOAey^Y;giw?G*O0{B3;!A zSJXWiMW;letb=#V*l=Dkq3_S}E%s9%h*J=@dx%$(0pjc&sM5sq#%n!Nml6`-I4iI!>YCY7i&rQ)3E|E;yuComD zLIMqQ-Vr~-lPLTxWu-B%d%lZsiP8Ca9YnH_*5>Dlxs#CfYHYf}ZltXE=aU8jF31KL z(lq68^jTFb0rw7YFYUhG6((NMWfWuGqPOJ9i16dhyR?K=y_JJuqOiw(;H2kA_uGzr z`ecbq=C0|ZZjJ^HfYJ3y-mGOW&Nu}$e(R@btvZ84&v0Lu^!nd!K7$$!cJs3GWy<9D7w?11* zmz{Ts6cc-NP4JR|i)9UjV(dX;oxC8-rG6f?YrCIIQL`maMiXtZYqsAaZF#~nlKKRY zoz7F;2yGc6{s9FmHi~uS9a06gPfHYD!y~k)3;AlkxG>K}ygcX`0Y%&C9vr~V$AotO zd5O#)*L&%!JqdCua2+kU2W3dxhHFqc+u2z}ipk+4`)+Q5Hipog2JP^}^5i~ATSz$bgRkuYReFEflsBvL8vSst8kC>1) z_4!u_NTwAxq6H_3U+BcQbYh9zGdId4MApxwmq{F!zNfYcq8Mb0Y`Gaa?(k=7kl;iX z1^1DS5=mH|5iq9N4|sOH3gX~k%4k`IqxA|PV+0Y*z+n4!+}EiRYD`xUG+lt--=^dA zt704Xf$xkD?A%m~3BQ9|ulS=$jv;A7au%J}I0GbkTS>9-mij!!AN5bJ5MP>oZP z&KIAm)A#?mt63#z7TX|v&B=H&C2DV``ha;!6wV_PC!tOjq{m729g;LcL!NPrE`+ul z!k_Fy2!YqdLPB6Aca^x(jSuj2F3dwQ+Y#ZbQQx%&5+OsKbSIaz+$}l6q^efljLH#r z@EpECXNZoyTCyXG`sj{i&dHMVW;^G2$>|U~)39O24eR3bWxA}3o%{r>Ddo(8O>vzy zQy|>oBtNH6@e--?6{GzCG0jJ38|H?{-tkaXZP3%(SmLfytg?}l_GZl;&^dtlOBjg_ zfk+3+3^*gyzn^4=e`ymPAd@s_1BWK$saRHlrmcc|Z=s>P+NR+NL15oLx7EkYxw<;U zctBhQ^F^WD%pa`wkwPEuvfs1mLV2R_7ua~(tsX22Lx>jy`K)eXGK|Q`@jMI6YMM{Z zGl_|;)^N++nSlyLhKd7FtK=zu7R+lXm&g~0cCu=L)a*c1hq{wA7p}V)j2vsgNP9W! zTtK_2=YjfJuQzzb(3Z!H8k7rq-xxl>V?udm=Y;d59sGiH8)q6S1%K+#08)~APZI7J z6t8Gk`6!m;s>D3HwpX<>!z<(%0Gqg|MdF2TR*OhQDQ7)!n}W5ODdr^A_DE@v#_TrR z`t<~>^Na1a<5Ou8Vz*rttau_bG*%VJW;HkC4=yrWKdGuYG|B<`s@lU-OWQpT^2fQt zup_1oQvd$8Omuyzlv4qEEho}33`r7i;3+1F*rq2D+b`MO;IHE#w&#GgRUmXXTozrt1WHv-6g3Ms@L{73mJ7b(K(L~Ve3d)I~i9PMYWw&7tQchr- ziARiQvI}tIu`zU`85p+0Y-h5VtIN&ylI$^AVaLAqw(ub5ns)}z%1LC!IgqPdjo47Q z>~gZC+ZFlGASQr;g5RYKSIq0Fw<<58y-ZgXMe;Z%oa%RiHtAxy04@kH-M3_XrRlbZ z8G83{p~#BN5!ck@9^J+wWrv?wDp%#)=1XZ7!XVgK%*pu3-!U|+Ax zi?2cDf!c7Ae0fpHVjnR9Qu+vShbKU>zAIRR*^{AN2ND% zJ3wevmquW)kv<`M*bqFE*TJ_{&ubVurk9Xb|!_Q8XQw~pLHbSEowWrvz zZ>`>D@3PHMVWi_49H9{f^y=iuHw6A58O3=kFj*&bnb)R)ekvPFAM~1cKx{)Rh3b#R z>Eqyy{Tdm^M?~&$W!{795u#&^ZW5TyMDm6Y70w3EE&Ci`U)r)zTONdNtcD5dJY8Me zS7)nTr$B2RB_V0l>Ry3r%Cq}5uGjjN-saBm9GUH1oW;Rgq4khbzE= z2$%)%3QdX52i;zgoc<>=!#|L;o4$9{#20~4k)QtOnXkA$IrHc8ke>OGGV}T#;`md) z&o?$RBtUHI)ItZ2@0bLcFeynUpaO9WrP{&{>bETAD)^1$vYf)~NA3b>jN`3}V3SZR*{CxfmQhXuAX%_~v4R@!9*avNV^6>s<@o3EsO$P667Xu9x{8Ya z&-3`FD25-yTr}y#<6wlo^Wdm^hScGK9;|)+CzRSLVvSxXoB12+t<%y#>}0lV94gCx zgqUA*>F}YzVqpLNpr>mNlYJPEHQek%7yasd;WFi35pMp;{`uzqQb6YSZE(7w0feqA zjt@YX2T2w%(Pd~ZX=KL)oKIr_v85JI_n@+w=pk$KyUB8VRSjFiN-ef)a5h_H57y7d z`z+2Tq^z^`a$Hp?w+wGr|(~!$Xh{^NNC~i1{?ex7`v$=Ho3v!0-YA!*d0NO$Tnm zV~xmxL}*aZTnj{9F5Q}-yCqzJnvFe<4VzxUONP**b#kjH>frcO(J1Q2ET29mic!$i z%E#Jh?QN(Zi4eyeF3=0y8Gly#ndEPZ)N8}j5HOf_0CFltAP3aEhX@azPu^qqvc=Qm zV{9|Qv-pRDfAI;Q3ZCs1;iNeF)@+Q|*WnXf>-!HF>b+0W2$wNw^*UR{y&R6OqAhYb z%lXqb=IXENZ=W$Z3~dl+Cbgah%LdWIdYo@CHmg%|hLo(-W~qE=PdS@6GL1r3>%Hh~ zUXy%%g1|8%ov+we`F)r3hmY|XtiPfN5o>TZEU&p~g~$o)!w?g#jkRWeyU!ik?p`oo zek#Ku06shkZ_3t098+ylzrRo5ybIaIyzB5Be8dqy3ZdgnAk8=>_+!W>?F< z#q15Q^T7_!;cyvir2XAb&I?e+vvu)s^Z^JKcwn(BVCB2Z(9j+HOeUJ8I?R(MW|^_H z5I4=!^|Ph0Hqfn!{LXCbEA0a7`y}mKNaFSHbquJcf zs$vmen3Ie2V&XS=*9zs5N#kJmIv?n;CMLADiao&NNdkaf;ccW-=Jb>E4>J!qA@~oB|*HLmZ zZlhrxz7OgwHNe`J{*ZMr2YZ(RE>*=an?} z-eu^n?^bImoHWG&XCxW!B%S%9+`-EID-LgqaQTW9V{(d3nkm>|l%TCr(3SvewFrZ_ zjC}^j_-9UjqGF>^R!PE24gN^uD=qyK<_b3zT`*9)Apmx3A)_^Q8}EBXW+;pn-{l>~ zi+ol!m_-;bo9R-&1svo5o1Pm!;-#U_)rm$ud$1FNy}|{Ubo5f`C?SJi4+m3Mw<6Pk zzAx3-4ANWV^K`gkW2(#3u$WC9{|KNshwa!4NpDr?Ag$vhVC<(HU8Qj*Bro;GiCqKk z-2Y|Jvv=;jXtJeG{%Z3cIr(3Zlix58apHevnEUlH59uJs{A$LSSn)(#h{Mc9=f^r* zpJVN04?TgM&9eeFV3VM^Pxy0BH%DgBS=Ei0T17CBkpnwWwlA1j5!*r5YIA?Uv(LGN zZDm){CLT%eFKOgm&Vd_2^PsJI-71#>+IbcZT|VceEfk|47?aPK9n|NjQFd4#piE2b5eDgVK3_{8c8aB{ zbVn^;VArwBZ_Y0^5?e&6BhM$c4jJ)*KF#ScoZ9SvbMp~i2qY#12Mk=XgU$myKsVDgjqwM zETF%vC?%_S4}eSK1REv1LDCU|ioP-SooO~Y2!IaC+2=;&1E_S&4O%rinN0FP_0=u1 z&O&VEbvNBQ>J729H~u$O2WqQAZ2 zDlH~PY0+~vmBRTAPB@D3vH+;ZFH2S?6^WuHw2l#VLl)%4fj4PCLq0X8K7q51yvTHy z_?A5S0K=chwc;6mHCIK?&>JLuom^r3^-jH#uY%P-;s1XAC+sVXom`KTsIM^I27!Ff z9~F<}Q*-e?zF0Qu`7CcIMYQ2F8-HVpLE>J#v-)!(tPpBU$F5#v7=1 znV?%RG)=*WK5onjxC(p?QLx#okp`$9DA=T)ozB*+Z-b^;HCZHnBfig^A}J7ofpDw% zChSUz3N*2Ur&nYJL2Fo7JiFH1?rZ!3l7VxM!=EA+kgPjIq~OyG>gmdIrisbt*)4() z^-9B0-Lg(pJwFzlW=TRt|RJnxq*e{4D6ZW+;9!cYft5cV@hyr>! zBM`d0dqTRaLyzgIbj61uIZbj)uS8SNCN|w9LTtVqE4xC|!}c8n@(ZhQ_-)70P3gHt z7#q<|xw665O>t`76bWrw!U}0$s9ZQ0^;~e|H=>lXLvBc!Qf>`iy|}-g!w45OXuXxE z$vz-|@ zi+K;=oU`fIUz+3rRYP!m-!GKEk;lwqu>^7;j!t$Csl5W*Eel z>E|zZ-SDAXRM99oe7a*#N!5|t%jt7%xmclznS+qgoW5!(1Z*Ji9BCoK+0Gz#s=r3{ zI-abX5c5Ob#IJY&RN~K&MSA+(^YlBNRfB1u79RX(YC}-EuW$=OKV^umD`X(i+HM{J zcZLJG6S=qRqRtXfbgq>7EMG`$A^*$q!hH9U@on9Ml?ga>HPQUB8-O?NXoA|CUB z5x9fayd0^VrgfE~x~)e9@V$*RfqGBT1Nwws=mC8o-7&Ys-T>gWUcyb?Mtz>q{*Hs2 z)!{73j!-$9y4%?<(kf!@nz`xk!QthqkXi1R7P)PBIZ}caxpHZ7v>IG5`ulzUuc};I zdu)|Zya6shQJrua^+Sja>VPUd1-Q|#M3^BZ7#(v;>{J=Y(O0;BOhRFRg$zu}{&p}S z=SwOy1*if+Op5aLs-I1zefu^*2-H%Z0pM!%aH^F!gyQ4Wy{uYsw7L|UR=p++x4sI{ zd#tlYa>)HgYTdOCNS8W^1rQN5AN1}MY~J@z(>5BfN5;x_hyL4R&Cd*<*_03^;JNb* z(=pGVmEl~OGcB^0;6Uly4K+2{qPt&W?VSs(`=|w@)vr7m{h+>f&_TAMHv^rOvd| zR%cR+x<8p!sX>xlN%x%1OK7=PoQmC}A3kwIu_36(d3LQD4FSS-uq1+ohz9b5au*b$DFI17U#zf5pDaV zfMqo@T;D4B`c*kHvn=o2kzD ziJtl9rJz1)Ff8jhH6RUUt9)HO>h&Mnbxg492w3;Yq|h`@Z1oezM6J0&nl3hXfx|w~ zNZr{ygaYDmYg&UZ`p99Kht``Hx8Aha*ZNDDkJewvU%%%A=h9#Ekeam1wc67IQgg6u zLoKb*xz&=@wXm_7;||sW(B1MLXg( zg7)m$9`C+BGjth>;?8F$WO};hegkr+!PnV5N!rS2oY1LkT0DRsQf zBy~D|P$Y3W^+0o=zFpHT^*M)R=~{-=xTGfMkO|aC9Ybo$r5@g?&o`ZSd7f@WC(JZ` z^P&^x5x#vvLv+FdpSg4%qd{|fsf>!>AG-AK5N6A@wAg;0;*t;L_RB>2>RReeexdiS zAEFOL(IFGP@@0DROWkMkX=d`%bl!$c0T)c1$1*G>)jN! zV75q)oGwc`f-^ZDTcjWOlw**V^nz5z*&=-)m7!YF15z1ni?mN_9p30HX`SThIHjwd z8Lej6ExP4s^@3$B(r#<@BE!@G3ilPNv8jYiPe*t>$y!maDJGz(KCPCWbf5HzE!L>s zvESLC_WO4GT?U{w=w~iwqinEyB`IL(A1(oTlKM!O+5^^7fgRp-#a2u5O{(=rznvF{ zR^ifD&89}N#k))YZc+8Rg_qO~{F-mcy~q{vv@VY9s7V?WJ+$oZL>{F1x9>rFDEhEY zjS`#Lv1`60G}$dWjD`A5TI7I?J}lkp^vPewYb!U1O;6?mTcc0T0%%V>Al&6Wg8md? zQ*5$d)7vSEASvre$^kgI;9@q0f=1^$wq&AVg^^g-5E*k_MtC1jun(uI8oB<{1Yu~T zea$B{K*@cAQY4u9F&Z~=QhJ3oPa6dY(=0SL9Tlzn3L%qnu_C5Z`W$_X%4B*5t=88R z@AJCP(R&%e-b3dm731#zW>PUOmpamlafKNf#F{s<)JvE`+QEu{H|&V<#t#0dkKYiH zpGyS3Mdo%`)>+?)^cKt=hUFGa?R&tU&-AzFX#3Zu14T46H@JEf&GB^uUn}?wVqqHe|Auv&Z8KT{C+*T;*nj3(y{&=E=%Hb96v_ii$A|wxTvFOR_Z(X(j5MMJ!$(-#Qz)_-tg~v$-XlT^zdz zJmGg=7@i)ioK+OA>zBPPnSFH@!%}~lD^t$Z62soV=hPkhcSPRJ7q;(#c4B7kYMqRV z@D^T-=;R`nFV|cf+e0}7a;^q{v^@S}iLEM9-BPfESh*IPFZrx12C0?@$W`ABb|8A8 zANMvaUM=z}wMv9m88HYNYT>@Y^Vyth{qEU%G?QKG%w+e#I+v(nNAynmc|OM< z`qVbx{%yX<-ehO1**tU>XDL|np-IGLa=b!%DgA>BlkSRg0wKAuA-FKFTa=fi~(wRHKGk3z@-B}!4 z$9NkmzZo8FRNh$>9@&>m{SFpy^;vw5=9%r@*1IToS5b`VV}2&Mysf42=f&+CUV(^W z%LAf>PJT)&b_gSWHv;G1%V6raG1n(03U`<2xt2HvDoE94h8#YVndt3v^1bf6N<)@3 z62CV!JGyeg=~8#a4xv144!>B{rDiGgyCY_(PG)GD?5yd+oE~NO@#2f7dtr@qsEss7>WuA<=_zSJeChsm?Pvni?XPWjLFkks(8)8J=z7kMX~1Y(Ieh z$~xkqM&3DNRWV;B`YgAfEgOS`Zw+k!u-5Zht#iUo@aGjMQiPmR4_hi(2e$`ON5Hcq zd~+>X0_NsG*(MA$B74t}tJLgG0c%(w$SxeQ;nPnxu5S;A^EMoMwY{ZnL(kmsz(Ay} zn2+K2sQ$Vjegs?%z6kz^q^ohI9E|I;qEbF7Qi(?LiOr!5@*@Kv8G& zyF7ta8DhH(vEA6-V~@|d3MLD0&FR6(@zOWGe8#s?#wYEkDqwt40U?8(EgY5^fil8M z=lBrQI~G)5 zLMJ)TXry61xMTX&PXwX&jg~(MsvSoOWSneMbSt;2tvQ+#dthD4>X%dND2Otm1>e5{ zyMz?|l9ZEfR73514@cRB5++JC)65Z*$Z1sUHg;}?z?et|+Zl{~652H!(I0ZX$j$5u z!z_HioNCsJzB&83V#J|3sg;UWd+9O|vvaFaalnXj8FKco4DO^ANFr6@Q8MOj`#Z;^D45BRV@TGB1a~KdWg&Ym-|) z63Q`-1~Rumk#=+hHibWLa>M$yne$ztA2hjP`rATxHMs$?w$P1DZt}NWpq6i}MnVDz?7ag&=+Mu@1J+<)WOd^PM{LtPp1OV&_NM*M;`E%H;kW|{n)xu#iu zPFcgDnh_tmMih49`D-Hb<5;tVA8w9Ui!lOs3hK8+If~AA#hnrloFPiuk4Xbx=EX#X z6ufig(S6oWVwe6VVP|lcv;atit%Z-03$$uwVgvhyp=;_kAKq99^haVJ8K=LKp zmN^@HZw!6W*n3vEym@W7NLn4_z8nzZb9`XM4iXqd$95HWabnW?fR5}N837#zjeI1{ zhx}v;=h41r%)rp4Oh%bxbRax>QTHAg7n}#6~~X-;1aSii=Tw>p*mGuB^o&L=A9|as{C}VVzzO zmL}>}`#0l^Ph3u_U;TzEtr36W;?cJX3`qSuK`A%?k33y`uofH^9r3dKFl>j{JuaM$ z(@(_3h7n!pMRe@dm(4Izyc=>6utfzRt%Bx4uWyxxLvt#(5L-2^pS1KHqAsH|*8Kda zyJDjb06E3V>7iv^FA*A2)vCi#4!+3Y%Zsvw9F}k@*9r^4Lz~ra zeg**yohMoWwQhCmB{Bef{VjB>sXUv9<6u*=o9K+JH7YN|cGmKu&)jZQy2D>Y3wp#d z8GQ$G03CO*de7W_{7q3>t% znb%DhBj)3l`9kS3&%$Yf7`dxG0RyKXh4~q!yP|%{cgglserdKJc0V3Y(E4f^IAV8f zb}Tz7KC-$L|ZVs&9}_eyd(T7b6^`9bWhk;Y$nDaBj`*|2MHgvHDPf_0q>4H6S228P4b7)b0ccj2A9?7S1QyQ5*6Q#}d2=&`N1{}D7$ioev!#MaXL5MXmN3&4yPiLM zyOwXU$voSI>rViDqZ<55MOUpj&Z_nG`{&@5^#{+zj**nLmbo_{C9dUEG zI=~*KI|J2ol;HD++~V9RStGWs81@VzZ{Z`HZ9yGh)NGzt@G@CmmgpC=V2Zq4EUlUa zm)YgrF|mJ0_RTR$5^1241_madr7sSilYRMasxKGz_2n&Y=-5@C$dB&Qi?K;$llAs& z3L%0+nvo<5A@qTnYyo74dj5b+>N?`fzAa3IkRq8h zL8;3g=dO7hE@`3twyL4P*9vZ$hl=a+zE(A@3E8!$aqJjIlHqLmB^fn_z1MN7jLpn6 z^H33i-E=&5j=UG`IBe_VzM5tDurBahw2UV&ZKTRPm3<)kMN^5$?{l*>+GbzO43TbVpVyP{e%w3Ba^Z+*m_m24t_wDH>^|D zXHub`3xOiJhfEqN)ft`Ddnu|3)9L0O(K)RVm-ll|qB#~|?CRRS8H&{3^TpyX0hajF#aE82H#qUs)P zr5~++Su5|=zASg1oFteG*KSic(WMoUg~b`+)76{5l?&v|aLz?L;)B%x@CNyE|62JP z!h}tfoFnV&ZdwN}p+hJV*!+OGrkRtcwB{Npf3w;4DHLoHE4VsRdN(73w2P+-x zs@Y*@Ak65aQjMLP0u|dhD}To~y|2_w0FKmCu_JbZu2kybhNvx(_MK4$U76(;?brZ#hJqR#j}Po(@LkRBN27 ztP|w>WaKBA%(b)me|3JzhZu2VXcUIR7kmQ>zO3E3GIN4+<*>}MwdnkCd4xL7N371^ zW8zeFml{upC`$X77Bmg0x4BlQyl3x6*`UE@sv%B+0WI+6$lA$Vzv~`Ffdj5l^_F z!T2tknviVDE2pL*&?)S-Zbf_|7YD>scb7Vuv4996GxKakvQNlrbIrOrLDh8}>}#e$ zU9J`iQ+-h;lX0@m!$z~zZRhb0<$fi{y;#M~&_}0it71dTOs^J~27ZoIK29fz_4SL+ z!X)qo_n$lz%Y#>|Lhvwy|1;I&(6zGd=h2}$>3iQ?Nv9}p>p=!w*imTPoV6_UG;qV3 zsnX3iTlB$zeZ*CHXo|Ba5KF4lPDRg+S?Q>{fC= zmR_QJ(=&B;IYJUP25n#QEtw*rLvg8ST|)rEPT@qD?@4z1z=+LQFhFm=6*{I1ufL%2 zMG~%KKK32D0kT!~Y}HzmUA0zKp3Gywx~fQ~kz4yb^_a|_ef}ort-t&d7~5@o=up>$ zp=mzmIJn)gB8_yup|Uh|D)%1YI|UK2h<>XYsWuw?ThtxgjF3%kuO!9D(*nXp(%DgtLSw`U?jj!UDh>T9TMOr^^;@;97(j6I6r(9SDEo!g;CBzzMeU9+!k!1QncInG0u-0qg{qC}uD*QrZ%<>6Y%;A}4C zh$g?Y`3xQc*3DT7yoeOOJ44R4&Fa8k7?})Z5?_VIV20V8{iL#5*ZdZwi^O%rYi4Se zA9#*gPMw!(?m5hi*(f;AXKrhJH*4Q(r*0JAA(ya=D{*}lDvlh?3Kgm>lp2$#MFlko zD>VY?`=NM_k6RaiR96wtjTCgB#c5&rFyv0*4geI9h#f#2-0f_ZS%m_0HvfzVO%ou9 z@mmHL%~@PVbFW;(y*94WoURGnX%F#or(DB*_7H;`dgbO&`r*dvg%{`7|)F zDBrZy0ZfMZ+%|pyOk$(%=1Fv61&7s|F;NDaC(ifI{qMq9jsjLd02fW{t6&}g)w+%1K$q=}|_`WpB&LyBXE9sA(k7usTJnX`T`_COBM^rVO^q}8sB!`wQim~3O2bgBddXyeB{S2Zq=N=erJibg1S}l@n z+YK-owO0N(_3+~K9A87vVte#zOLOeT8JvT90YcYRTeWNlxuxOMD_?`|RIxsj&((d% z6BRu=>{um=Mb4FNwbtbv3G1Q*(j6b!(@UVu+b4y8gn46SHXAe{lr=l%sA*x8OfpqAa z1-i*$I_O#>V_EPvIL$zQhK4u{Pcbl?_C&N$nmSrvbvlZ~ZEW`2yD&v}%o(N*zMVb> z&Z7W~#J5#NF%yiss(KzMRJG6WW@4oUQ^$sbxtm(djx3I}$|2)QvVzQArmRlV{98w7>Ss5P&J(8jmo4xBHu_1OIRE`M2j5;JZL z$5~`Cw4;Ufc6&}g20*W1DG=FE1g*c5`l*$Wf1qmGC6I82dRK@$%Q2L17*9Kw&xahq zuI4IuCpS1+c%`9cCmPn7*`48mlB!;i^)j#0>eoZft$Z7ly;XlJSC8>67_EmW?BIuX zX1h@*D2=tr5E)TKm;KtRZ?ivB_0i3iD?@*)njzIo-TbHS`qJ2KdP6{^0Ffyw<&(c^ zz}I|7e>421k6a*Mj@`=&lgDmziRkjNp)?)a%XLGsa3F(}99^+`L7eqyaPLLs+@Dt( z!$n%gbNq+g`I3CjW^p+!_qsu6%kB2#ysRo`%XP`;oLihNwLC+5O}a%6+|BCk-wRyW zy76LhXW%=wEN*N+1gR#aB5sef8E!el_YeL65@QQ*mX*W6e*?%|JyN8%L@g~NiB zeCS$vRA?w+Oj*w=DG})`0{biy=T=#?zg5?=MJ2#!Ny+wLdOpr$y8`t^zH%()?8O5q zxD4e>eWIv$=Gic4`_s-j)fhW~UO6MD@>h;1FWBqu9IwxOS!7^mlPatV#Ad)c?Pll7 zY|fF83sy4Aes;Ee#&U_vfE|oYirfv#7KJof2BBYOPL=ncmuUK^X}zphA02ZOhS>4# z;yQ&8i5!x8O9idvM3f|(Mz~rkqX`uhKD{#GKM;=~bmL*4`DW0XTgvi!19%jY-m{q? zAlOeiE?-#}Pz;&DMhbrj1P<5Z)7~q!4?5}yqZsmWoY8Tu6zPDrbu9X`nD$q&ZDQx} zCtz-fozJhj@aE&-<7t1f@$oTmX+2r8O?G0_N9AA&;PYoErpUr#8$5&c@5+ejIP6xh zI(&*ue=WWVBQlQ+bvi>0TF-RJH0qHFwnHph6tZmL*c(r2J~jkmx1l z^jT2zm+Wed!>ucpKoS&_T%j#_i`9YY6p)*N%aR|~B>0+WZ#a`93uh|5i)V4N7gh{q zSuIOS`c@sLR$^1j{z6CU{&vlVV}l;e&!TO-!TZdKInha{#ZP09nc;yl!04o5@dDYZ z;avL_%wG60{bDOkwsLMW@Q$ONdr#^NH3;PZslHC5uV~O+npyyL5bzP&qYm;kHIwQC z5=rwjgPNld$deuU))n@SY!%RKS}zdVe@B9D-j`ujBK!;??%FB#E~0B>`Y&^HI^>Cv z8b6A`%iJoW+udxN@B}N%)hrUyy}G^M*J!A+v?lsj8(uK}=&a6=RnR5d-@~5f?n=Zx zeh(;_?FJztEJq*y|5FE|SO!4PoXZ%)Fe`e|!v1;e-@AuC6?9Vt8LI9qKW%57%0w zCkCQ9C5Q$F2r90IfyzU%GqS!&z%LRT75a7Ame8G%-U~wyW1{SA9!L}VVU>)y>~QEh z!$ZJ#nE=S4m4ee?-ZJD)ewXC1rXrKttah+olD5`P` zWl8%(rO2S&ksr9SLb=+i(T%XHM&!3Li}0GlnYxb@1Ily}M ztUY$0twvoeTaQX@o2kchg*9`kVLd09Or*wJk-ubuBJXr_vvkuVI?MS|Tw)X=65gr| zJ8^j5XtlhF;{-aIOZj6*eeNH>cK)xi&4*;1lVzNo9|C0KeXHq@pz3!o1tr?EjlSm9 zY7>`ksa0U^rBC)(^^E=HzgUHz{UO~SK{kk-k&EfOW?`bVFCEd{DU->)SuO7p_}r#V zavD6{b770~XYFqnPk?MG)Z#sF&w7Qc5SAUjL-et@juz>`BKjD}q{N_2NJ}9a7iKtoWGd zL~^Ag;yuA=L9_5z1G%y{HwEBFD=tDIuh!gT?A#Kps6kx|ox1B?ft?%Cs0(^F+hnUz z_LeqVGTIMfrwwg%&~Q%bk&DA@p8P$A=iscgApS4V2;B&ol#4f=Z2CmoFA4MF!c7mC zFP|HKq|lZ;(b4fzL%_Nx&xdmgts{uSnA~YF{GFRf4B+!3Is_Ww5wfQ<Mv^(HguWj9~u>4tvn9(=yk6C0T=oS)Qbgq_PZN7 z-g-$SbiG>PJOsG0EqYEIpXADlF_<2s;xbX8+__bV)Cyd3)3P;*%Y&Xn&U@KrlC9S4 zCJ(Yd1E0PT#2#z|h=y!p6NEkqU<4hl;IdmCcunTp@e}ICi6`YWC@_3xwk=pO$f%f* zry-%M*0UA$GS7z4pKB%3Fz}?{ZsL!D!ElNuzKtC>>h`YfDkfL==-@#|QzXbIb%ftGeN8kg``1#H>nbnKXoA9sj3suTsRl zisDYCnEMo$dK!jj1$z?@T_U~BVJZ=2`dmh3X81%%|3?NeW_l=ni~8u5_^jssU8v@~ zl&4VS9VBQcHNdZyb=Wq*a1oSBkH(_aXgc$cF`@JdHZl|^Llc7Fx zQZ_R3AM%nOvsL&dTqRTUZ%)ye@2{-6wAZ{bbdnJn`zZGmqKR{eLn>JWdT^ax;vbX{ z>>D$s6z8_g-{b=6ptnd^(OflrH{=X{)lleLp}(W*E|{Z0ju27C4Uh1*W~xmurt$m1 z$NJy0*Os;S>0=XHCnv8J8?Znor(mfO`7kpar=su(U+WOHRM&A9fT31O9rC2l1^`|k z5t_!~I1~7Sut*8Snm&4zoI&#}q$9NOX*DKD(chG;kmBZn+LrgjC#rM%`ga3$$1f81 zJ=G`=AI5@z&KRjvyq$>mHDohM|7)VcAU6ud>U+Ny_#j5H-0OT7K2r3&qUbj8$T50a zNdN{i%ZO&dcKh9Tl!k|?Mp_ilkh#v4T$!N?AI;TTaL$#R)i%J6nS0mlSbYe(CbA`~ zA#!k(v%1@=dZnSI9aWkB#Rz|?7|Toq;;S0?Bb?p`{H`u1m6y@oysU9i5ijnB!E|ZW zbUMb{n3=r!t-3~@y$z^``2OB)fAP_i$c)`#W*WgDTuTz;1(Qk8?>ohb~ie+3Z2imFvpdV^7Mv=QU^KetGbDb~~5+ zlBd;oGB^s%9!xf0SzD~x{`|Ug$zu6@;E2!bVzwkq8kjDhXEGUmrQ2f@?b5F~m-ys! z_Yt4h#&8TtcA6GxQiJE`dX;7u(DW!-rdTe?aJJ=o1dNb8H_4 zjC0AEcDh%mZ%yX+JC_W!(+!=@k+16sI+uJ3E~lP4o&HEN{c7iuJ$CvuoqlgJ{YECy zPM=Qttl83++nh_DveRZr+AWfHw{ywEcG^ryn=EM|=aLpXZJwlEDrpOxOTI5@%S#$* zfiX9*(IY(r=MIluN4iXhtgO9YYjJoLKF7RYyQ*dbSiToLYc1a+bMmn1&~7e0Yv*Q1 z+V@&M(dV3l<(qHy+e{f^o*<8oC7bEMpKeFO#_$FQRfyx$1+|_cPPqXEA?sbeRIu zQV=<76T%XJkk0I5AhLL)XFW?A07%-q$+R)EeodNJr)^25`Dgu*Gyso$Ym#XI-W&l) z$OfJM>ts5Bce9-i;E{h>G9AF1Xs1sneHQ)GfOnCd2H@?U^({#Q@J_eW0KDC^rbrrq zH^@!{@OIC-Ows_neFAv*mo(CX2E4Tz@J^G-*%WuBLC;>6EyPI)kLFvX*Eh=%>Ail= zV4r8xtTR}-AIu#t<$Yyq8$34l(Lfk!-w5%!k&EA4pJ(grF#<2<2A}ikPHPxs@k^d< zK68Wf$L&5(%>2;#VB27fU%grF?_}A~6xj$plsov-*e)ccK|*`(rJv+D95j=MQZ%;# z*=}J&Wl_kbR%}RvZ2Qj%eYvkAFMJXTLJ)o5kRv!d7{y*MCW93n|HXJe!1$kRIpHDv z#X|spvqI&<0Od7%7>A-&mU^AH)CTlXK;uvi7g#PiOv3^O)R7LaH~lGC$pk z3^>gvNw=A2SY{X(EvGpSk6Lb*cZ%B2Ky@?1OHtDO?op+avX$eM@8&8A9@pm7SZ7nYcNoZhq^ZnRde zKX)hDfMTtZ&XuWJMahh4wUGbG@7?_FC0~!N7gxOvC0ZIACAueY2+=Eq19%XG$jvMD zK9Yh1|Q^>DrRoszKaEE^BIOL$p<-d-BTTT5u!4RiwX09(|Nz8R{HRO7bd~ zPE4iM+9LHM5}`cNz!ln@rNlWW@%&!m};g#<1ivTkk~`w`#P~wu7EV7Ci7z7 zQ>X0UiJKOK>?z1RD6GXM9Kfm5^XyxbaK5=UQCP}nF2}yJri=Ep7)(6?f-noV9*}j_ zmMktT4^*xQKvXZ^;+=Az_$mqP*OSeH$H_^K4iaPyc1adE(#@)sj!|X<2^bMcYippK zlU^IN^vW%ZCE^3S-&#zBpj3-Xqbp=lS?2Rp=Y3M_KAqqxcxreS0gVB~G15f|ogKLc zAA1hmK__5xqXw zESQ_B6%Tv^R7<*6Luz%XF;Xi|>?;$6qA!RZb3t{o1b4|&q$XVirca6tw2O$Q`Slbb zmo1RcLgC}}2R5wYb+h2(p5*w@1RbD07sR2*H{2fIUj(ce-yq|Tw*@$iY{X=U97NWk ztG4;mlVNGt_;MfH>KMcz)x*>jb=)VlLuck7lq^*Lv?nVpE(4*IGUBlm_se>i1>dr} z0=s@2g(C%5@Sft2Wo7Jtw)_D1;-ba|U`QNlYr^(>7@QjPN~ zZC;{r4w{2koTfwpisO}>~^+Pv0AYxnF8jMhaUYFCIU?A zOORBcs6^pQ@6)8lK=vh8qHs1T5-&7hO?!rnI?i+90CWsg`+mK+#9BjIRk)eR1AJG1 zv{O&f`W++?Kd@h&Ps)(!Hc>=%$Mij1q=QJJ`e1>gRwuIk83KW6vX1n1>8=8ysGbb5Q@o3z&bi!@rtk77{<{Kt`fuciS-OcI@h9|v2wquW zrXP4gwT8Z!yVU8@+j3i%g06W5nnr8NOe>s-GKZUVZcq_&@ZeUfBx)snosrT!qnkKH z-SCdcBoiZFN&Y^ke@(~5^iv16=G&ij+7bI*2k|UtJk{juw={a`D^n1q3_YYh{4k`~ z_<>ngYo#X)=|sJ1j7Fxvb{zvc#h(5qK~^&TdaQ}U>uBFTYM5q2`d41Km|a}tsQCgR zeFOt@G4gHZE4_~v(`ITPjZU>#W4GwBTO6ZX9HL$nWnV^({Ll^o9J`)IWx$)&icA@> zjk{%U(av}1Ns4~!zYk>2htn#qczmEk^8oiL0!HaM&#_zoa+03&ef(I)P&FmlI&-cu zrTHov2YcEXb%9_>{dzOkE61JYf0rUuJs zk{ftDwf;97c>h~pyMd2@t*6HVTL)4rorbMdNFf>H@A(0~|GKv&vI@Cxz<9GXIJj>2F)Xq3e zXB?!y;y9)0oBCyxe$jN6oiSTyEKob`jAQy`%&;?l>eo$w#*by3p#ETIEbEss!6$0$ zwlhk8%NU}X?2Lo@W!z_H{Fj|k>5M0;X?DgK?!9C#WqST;XWV6Hd{t*0sxGiIcJ<5n zhMn;xJL49eahMt)8TBD0=N(i4cHV+w*9Z+@SOp*8E6z4ON)#@8Lz4hUuIrm*kPWLD z34(6ox|v?x2l2x=8~I@^n)tDdZ1u3MbeMvSl#OZg#xVZaNBlisa1Sydu8M_v3lR_d zL6q2x$l3f~2LtY?DjU+nO+ImCcz(3NiTRyf6VVyXIcsE<0b$FJCL?ma?jp3|*f&rN zb6!676@IwRn(iacOvIB2P2%t2kZ<3B%+Q#91M=iLX)x=?RW%p`>%a|w!LP7!2Fn@k zy#sIx6EO3;2-VXjW|2|<_R?hoTK(JIxM4tnQm=D_ShJ5wL}fvdcDM%o^qRAa3ENN_ zzz6uvnx{6uCLV9aJ_c#jZ!xT~rMlsExqv5Fo?)GaW1ulGkp8#159FGRd(}CE8iQ}U z8)GJIb@<b-f3B_yWcJ)tWh{uD)+`OjPzuO&y(l8_(+`uC;oORD=R4HP6yLN$-$^x4(Rk2 zNiw>^k&e8`VHA`u)VZ`qOxjIRKeZV9>|Tw0B1294mC*HYp(o!deF^7lnTpy@jsKfz zXNi(!8G1z;i2BY1ly$7Jy=Zb6WA865p_W!al!v_#3F=j1*;t6OyrSh2f5DPGFP!86CEH_;MK^k{6EGJo-2- zSlS*E<9nX=ATCcBDPfx;RI6JwvE8!yW~u`$LHs;v8+J{a=l+){!cxAJ zP{J|@@eR#BRo`pY^T!aTrDaD#cWWe9Y}6w_`ixzv^zvxL`+EF(z{o>yS3_xLL=q^* zdYf0lYvT^m(;F_{*VxE&X6R(~7fNYC7_5|fT&nP_3q4PD56iQF@%yMx0y=*HU%Vm{ z&A0X$^6gc2@~a>?i8+bEFPoWN%+lm{b+CU4Y#^E?yC4hRebNSiEYOywH6d{OWMPp& zk;Z3QnFC!8^f^xBf9buxVaLk5lW@}g?KGT-%1H`F97eJ`x*s`h`~2HjnX}bPy1$I2 zn6Xs6&S*v?3Ww>@s5|H!K0TN6)0r_)W=q4)v$Swr*l`>6Saux_7pSY!MdEh@EYm!N z8wUX^b@+y3W}X|MVI>(H5)E((=1GqPRz?Y|cvli}jNhZUyNyBMe`3F&4IQD}bj*B@b5{%~t4|hzMYQ^b zVEt!8?U@n{rTTZ6qSTuI4zwR49Qb!I)GA2qIGg}A2dyz}HD+@xqaqs(WPeX7ng3Od z;3Io)FnaqViNaT37AgA53P|3mzw^0&P)hU_bCb$oY9u9K))bk6{Algp<;3E&$_rNB z{(>{|6en>lzI)pb(%?;>n6HBKtM7|0{E2PO(bTIg_gXAy4#3RZAGAh(haS~f`G>|a zy2;tg-;gdzFp(1yYXh7UiS|I`uw%i;IIwd5P%y$|6PJMGnc#dj*fVaT^ZDPLxnfv$ z2Bsg_{*_k^R$9aESqRnsa^`p84Q~(CG(z##>Z9 z&J{n6;hHVO`Rsrx&gY*j*5kv|IYvtiY>QFfj;}4}eIE+t7G3zX5e>g>c1C(rO?CHc z>S>yKTQ_x2x+%~{Mj)Fgl^+Dn?{vnrl))PD&uxbjmz<8B*1W+ddDmL7{0We&EKG8bm4o5ZRX2zg|^03_7Il9LkjKHB83`ZzVBNbBUKP!FuEaAa(o$#OyP* zpqWcGIp+h}3S4Dy(lZPkMTNGN3KGeUay#wWFgs*eBAfSoIlE-p0M>uZpzy%Nq`Z#o z0`!KpA3VcqE*Vc7FbK0=)trn*ySC!EW@^fI3)=M}AizF>`visx*>xf`aCzpW9M8I0 zPU@faQ<;VjP)iW6$qn#t2;sJ$hHUrbp4#KJGjiBUAJ6)|>y= zJS^aX`v0B>XQY`0NYBOj*iRVPPoR`A2w%;U^0FE_vkQb`%WBZxN-%P3E*Y1cm6wh? zD@Jl!jO_=Rmh9J=o80b$%}b~Mw{xQ%KCYTcpHyi{YJQ%7BRxOU z`J&+jq2k(V#6g<&D!38jA(@}rY@+4#=%CRlP`S+p6*+HeJsr-7n9=D|HsCot8y)jp ztaj_PRJ6$~xJK^xV0`&514(ejS;TdvbY+OpgHLjU(&{mx%-z0Yq_9ZwE-aQA`J* zxr@@q$JeAa80~P3)o29Qe;PS_I6R6#qwY*!5Ks_kmP8FHl$Y~_!JUv7x>4hoN0&6dhgkCQ<^Nsg0! zi4MuYS;wxe^?Wt!e`5%qxH7wPBmJ!2rgiMaD*9a*$ZBlClxBb`kSsW|w({Fx?%onVw?=k*JQvJ#cu!`=GOxR2$(SW!B9l)UR@}5m z2T~4?pv|OU??n62j(??0F&lAvDQ(5RqEhuae!3(UB+ft==1BZ_arL>C!w$kyoi7Kv zzUrR$k`9>L7A6WD!E(!X2h4RbeUEMq1@iCNkJPwKgg_lK%`)p+$RM-b!vb8Lm5Y{7%u6`&tS0e0^NExzT_uc zIj6{Edj-Ig(p}jn#Ed|aBiFM>SlXgVUptS}uHTDnyk#GEA#B(e!A^dYhxMA? zq3HCWbsqA{oV62{g;b@q>2ux>1JGGH-xbb-g^#@|>sf!7%P6}m&&V#D;9j8I3z)qP zvB&u$o?+(68SURmJ*dmp$=^FJcJRH~$Aa)rL;WO=*vi3kW%Oy9vk$xHiX$#H|l4BCdBNVSuhQCiF#199|w(JDB3R`<-&z z^i=p$&3bUCzEi5X4-`OT-wUCDoP3=o{}$1juKyK@QF&Ot6Q6ztb5c$$>BYC`g2WvV zF_BlCS3@T`CQFl^O|vT+D+|KI&=umXYxXIP_hb&@HPIe-I-kv~aX#OiA%X&2j>@DX z&>)sQ@^=JM#A~Rra=sbQv2g}`jx-EunK@LD1M+uyZ(1*t+;| zNBWJ+*x|U%s2qgqaVBAV+JwOVf2^Ggcofyy_;ZC25+*2t04fopMxzo1HE}_+uz^|G zV7#DsL1NK}6>AE+fC8GhiDntsT3h?+*PFfD@3XC1%gtK?LIMZ`s1>wAP^)JhFHtK* z)a?KFo|#QHfNlTJ^W}LqGjrz5xu5sE_ZNS`0UY1I$0kX^Wtz@4!dowyOv%*lkGG;~ zBzZu%u;_ARIh-+ldc8HSUhm9LnXXNh9iqa^uZv%|6J_}Jzotr}jxr2+H>*Xx#DQJE zLZt!e@LOwDwe*JY?b6YDKj3h0QLo;13>DrMomeD`uTIl`%e8+*?Ib6*n{uU%TJ8XB zo)30iSJ>=;Xcj&8nUJrqtM?SZgZR0Dc^wB^!Oy0xd@HG2SI4q z#O-nr<%f2srW~9C`nXQE{uaIUhob1C_wa9Z$ZxETPms{5(88r&jl@gUuY4xwUn+bl z={_Rr1$|&mc6dAtpR?=^DQSGX0j}QJSddWCT$H4IKazNFCL;5 zB}65QU5@w1*VXNWiq>FzKqwzjE>w&_b=_%>D*GM>P=Rm+2l0L^@9lm1gH(yTy;T(e z_vQ3zYzb1Jmbgj4;vOj>O@}U)xAKL9l_0;{s=fsCz*rx+yH!m!1R#L)?5_^v;HPk_T|iI20F=9xzF$EGQtbkKi=nPX-Z}Ew$F{# zd9~rgqm0Hvfr7}>u_W0Y8b*MOMdK-IP)K~fWO%KeHk_c=+Q{)$5Fa?4Ses1&mqbq} z5tYPsu@QVNj%Mmft!3BNL3c%-*N-xtbsEUAYUBBTdeI>!eoxMFCx_Aa6CPl8A?_3U z<-kFoDl=b@8iI2T2^m@I*%->Ijg-Vhm#vl)aVcjK=bqVmSmcPB(-DYf2zIa&&TGp` z-=w9@zVZu!bAHd)%V8&xwR?a!{O-kMfvuEtu%dZE`y_jAZTW(tIMztY-{s7Fm&|+)u#Yvk-}?d+#G(I%5kAb#%B=b?m~)s3 z%z1Tc{TI2RDhK>GeC2_#E9^;E_@}{N^S|m3@*X!Hp?k3Q|rve z7R>>P=XX4>xALtxsacv5{1$!q<2pE)ZhH^LL0vrIv5QxJ$fm4s=~; zUsKQe;U%`u!F@u%i$3=@b(l@8-%#eYlo_1JhX~Trb4l=%U>Cxjc86uyLGMaLK+MOW z90Fc)E4^VhO7?4irjIim@JD-d*Dv2m@6w&T@l4+}YT2A>Ox zTukYNDn)d|RjQh3O1Ka|LR?)TUxFwC_*Mrb?rI-y>GHI`VuSbRX^m2o z+=6EJ7NjD#K>9z`k9D;ki3_s?x-L*zSXT zHG}1`Rrp%z>d^bqfVfI2b8a_x4s2OGma3<8rgn{1yw^=Q-=64^wey_9_oB zPjFKus}M1jStSY`Cw9cZK~Po^3a0`Wzb(M;4O1Gg>?$)Ff5A822ILuZeS|vvAZS*p z8lkI_p2vQ``^u(wjK&~0j8#_|zN+SPk0c|w13bB_m_rKz-j!YDFVQSeWi;jlm1%Z# zV@tLK&jDvV1-ag#4kGHDpdN85d4`M2gLs?R8nMUNc3$fPTp-wYyP1Oof&XCVhn|m( zDIWt}vRLcTw}`@fI)qWC4si+KE&~E_wEC7VFNY?m3Hp}YDKT`Jpl%(`T&lVj$&+@w z$*8PTsVTmdP9wGMBiytNmqdJ@l*;f}J>oOC+BrjYzs=yCY=W)}y%)9y?`Zlkc$>F* zV0@e84Wu8o4o?%fSc&`nEA;5D40L(C7j6z#lGE#LHoVb05%%c3@okdV>SK66#+;>6hw1BeNX5%G%m`5U1ckRLe8PZ0J0d* z-@i%&`kMOZiyr5Tw9s|>tsntnD!3Dmfv>^fjy$U$g6P)2S&1i*br>=#gXLZMB zv6Kl*T2V%mf_HK7iia>50*5b+=1i&L{JiExL0WK`2TyZU@IwCQhDHT2)5J_*5k6eY zOGB84ZudSXtJxmleGU>DN$ZB%h!KcRPXm9IqxK~m=UKUn-_>Kk6R{i{!(VdP+!;@g z$3%liINE59Z&RC4MvBd&RoFj03kZQRI9mP1>V+8h>01$r#(ul+DBJ@; z=?{GW{{#x28-dC{?FW_5{D%vbj}j>SvXbF<1PTMmZCci^>kJ8MkziDUL*Di-@K|fXV1V8s^TKlcHfN;m8 zwNp1H(b{mhThx0{IRBp3zV-TJ(Arn(#BZRrzelOz6(<)w);eb9}@gfexOoNnQ1>^C(u&}B{N|L;}EZZ!G$I4jO6?NPThTs}^|5=dbWcPg!S)9)nRM|wQ-q&ErD(o3h_ z*wrv&n7FPp!xyK7hOHG2lo~7t8Dgt}Ds_uM7ehGtsJP5Hp>3*o80Fxd0W)TB+tfmN z60U(xvG7KcP8KPIcXF}cI=4kuSwim)e=ud*l+2m}iTrx28YC*Ng~axhVYvGyN3-=F zCOJH>kVehR;-6^wI;ySC+H~z8_UfZFH9vra_$8^#+Mzmdy&z4Wnx!i7*Cw9ah?XN% zdWD@YeHC3rGdlGI?bJ{5MV1u`K`-Pxtxs+%Q>g!X=Mk08&Lxu=49yxb9b3Bx|Ex{0 zPLcNC%kc%#JrV`rF$^}gb`y5R^CzL^AzGY&wR2T5Dv(DS+8qfW5XkB5IeljDU}Cswhp3)Sc;y9DCh6ma(4zMnYNC zMn*|sKh$eS3T{#-GMJ?(Q3Qhsvq99>1^3_MgRJcLHsXKhN>O9wpUxnFLv4;&N8f{>;^I1En129OR=&;Q_OiwV6 zLDF>HZ&}H>+&xD|PQ=;bmcXky`7-FmI)t(-B-yO;*wb2YQO8%6W#26pmF2B!a+B-< zWX3F$0?W*Cbkaga@^Ot6Qz$fWO#pfZRES*L)kUK?Vb7ox)2c6%i@5Mbr$m+kamB#B zM&g5LL~Ue%uWaH7Y_7$HAZ~{}UoU(Q0zLMzjNAgmp|=_ed}?%}{!o=2m8MCThR^|ea$)FDY%(+B zM5vawJMCU4{5ExfLD4M_<++EPG&PnZQ;8Ov!&zOR*{Z~tbM+MZ@q9rLZf?Ps!?kSq zW1mBJzL*5#QTu8UHbgNp(^AckP~V685QzUT8Nh!9uZzqstY6Wsxxy%Lah|=T6OZY` z;s0m<21{lCmNx(UZFr%x4HwI5fi3!BU|JA!`o3Ag`kwMe{-JU&$4#iTGzCHnRnj(g&L^k=38JX4Li`?9< zcQADN7hXIqvwd?C+jkGgOW)Q-QjplaBG+{EDm3>&&AQs%y1(U%%CZ~LKGpEJLALHJ zfY{UmpH-dXZ8$7CIby6?wFkXb!pS0jX9pu5=#c20p>MMyG00`(YHf%r2?>Mfh*oSS zii~VytUj@OiR)cfp0?z)mGF}?E;d$cFCEgOTCI8^Ww5I~Jq!25hVYQQ}hYwQ8(MN%m`sE8E99+h&mP{1jv4S_lm zF)77pn#OmOImjQK7LQ@u2FQ8)cN*jvO&Y|>ppd|jF`Lo(mVgelEZcaE<7(!4=R$M3Y~Rpb8E+#{Ph*Ys>! zG7;e@%j515D}A}0Q=2m`fIE+~&{k1}^lVuk(^D_u$(fY^*3I`q3&23%6swm4MP|;l zQ3f*>9OKR@yg1|jOF3V3T=RGXt&sT;mH-R zF+m|h`DES!UYI2PItmg_|MEY8gj=eQ0SW)26ORcA`*7aO_}_$Fecdci3l6s$#4Acu z=2T9RP?mbMiqQepO5k)ZeihB!>U;y))za^~!OnLz$NtXB{4wXjk#)UB|EVkMtZ%66 z7U!Fz>iW6!UB{XIzjI-HLdQjWm1+1uuOlmS^s@=5)`iu!PAv<%Iv8o;u-; z$zn6N1Z<)bP?Ux1;5+SmWN}(;t=(B(eYP5_I0DmZ%TF*@4rM0DbPODgmz-|G2vcp=?p%Rg0hczX~YbAD*a!$Jck`ZqS4J(_|DN!6N+ry8` zBzz5xKipVdsm5(`-&D1`Qcwh#Y=8!+jU~B}$qkQ}+EH>;igvyOpWvQ9V1RhuBIVhKiY!GkO zlKye8`2>D>#do__(-&l4Jpc<9HztFy zwE{DGL)@Ov=xQjJnnIcCndfEG6{hGJ$#Q2z1Ts~{=7eqPSD%Th03&KKq81}+F{06% zwUQ;m^$H0@BgBFC>V$Cz{!gEF*Ir{$iypUUQCWt3Lu?hpdu#ytP~@WUVU+S@SOrt9 zKx4JAo(J$l#AfPr0e18DFeFo>R|A>0D(g9ih#H_$X|P#-kCOy{w{~CuubTLZ2C|URKHrZz6t2-6HsM^pLt81RS!akUJ?`4lAz{vKaVra6MnyFE z>21Auj=v^#S0>f(M z+VERh@%8E^5kJrCa(7sV9{Gc2IsqxBvBSE|(VNY2?MCBId0`U1)ZJlTc3A6CJL~~G z-?=-iRMzff z)iFa(k63dkk8VH46t(7x_`uy8V%;MWw6R;;&s5eatpzPL2T%jmAA}Y1xDb`J~Bx(dIsZqV~X7XgjgWDw{fkmjPuZ zRWuRMNci5Ie^sV{T#24j$zBnxafU8eoAET2@L_C>d~Izv)6smvhS1ZVSlhz=_cKQ4 zk$%i|{j7jrIXMuL7}YGFoCC-gkJkad?pPSLFQ0VF0<7CJRJU zKY2k)p@bXgwD5DCF>BLf#?Z1shxd+~x+sTLFPnCheYQrHd%IoazL7AemnIIFv(;sI zL$Xg3MNKTRIeU6vWvcUeHQ}J04Wa~+a@5f@g4ay5Rh1LWmYpikD(;)WwV? zvwB#Hkvs6&;teRX$;BBTt?Q|ol}>2k-H2u$0-V^thXvcNW#A{abqHwLgY$Rnln227 z)JI$|!!!|d7Ss(_`ri<977?nD5IVknB==@1F_K&BTyAkL^SLDE4XzoinLf|e;SVYZ zOg6-yYgt#Hq5ELML*P%2ZY`mHZZ& z30oDQGlt|AyE!-3#rU=!$Us-o9#lR%156;?BB){LQ%0OZj#Jy~dS^CHm{$AugzL+y zJoljPjXf6r_w_sAi;v`HhTPm`(~coD)JtX;UNPI-OK^HtDPDCbdHYPl)jGZZ9$ju0uinews=dP zZS%oTe<$-j5b>dIf$qavSubie^scm2vqHt6veYq5b^VD(ROeY+k&3C8?gBT?cJBYo zy>x(>u5@5)RpgE=`C`3#QNBRWCt~K=&q@VZ(V6LLHpM#?{q|l)%VCx$V1vt}e_gy3 zL1_bawx~a&|7ec^_7E-fcPs$pn&B@y7oVk$yCaD!-X|?k=l(>aUHb)ZI5nj2QMS(A zuw8iT;xkFu>rw1c1t#ybUv}V^IVhlWBb`aQ4dCRf+_u} z?mq!L#?b)akkL4b8(-PEq2m}9qw#oY7YyoHHaD8*oF$#z{2c)VSHQHoyq9Tp8oFk` ze?{gRhLv!eEnElfP%D{gXb_4fs)n$H1Le;M&smuDoJ_wa1+(DV$Uq&;2;*BJGvWK1 zD{k}=@~j@Uo5be1Qa_b*I2~HY&0~CU>(mh2}KcGX!yz& zqcJH-Rz;RQLs%Q^W|z@ndnnOi06FDS9;Hf=M48EQiroqlz~pU&F~~w36o{O+aVvW7 zdYn0a79>QI2r5J~hu}9GRt}xe(zt7B24!tnxxT1#QcGxn4k95>U6VR_lI6dFmejx1 zU4OVMYG&e!ZbLHt1k7V4eCyW&e8EBW>GN#S<9vp{nHjV|*pt!84V*`4pTMERw;!6x z_+Q-R1z{I0Wd&R9uz6@t)#!tPaTvRN2+y%iLN~@^6X*#)nUfP~;?s6oe|A<-hi zRv4>=83QD0z$6Ml!7jyHkJZ(^2!c~8FKjo$zn2?h)!u;T%}Q%`z?k}~eUh=tpz@Wi zMJP_zE+@j|>bwK3! z*opKbdT&Z`JU%&2a~J!d#Z!i+h;QmuEeWcUYmqoIikF5p29_fla&{P#PcAK{lPG|J&nQot35PsAo-ik{kxKiiZd zR=c&6x!AKd&XlLG4|`HV)3Fs>lIs_55L;E})zmR>O$tp($G>*#5||(BTRXE)N%`vM zU$LSIQHLu?nI! z^dc(J-?_TbEG;ct+sntL8vSv_4|hSv!j4B_P7x#7@T3bltI+(^E+>I7peBG4n>j@_Q3DyY0~nd-i|V=h%EpJX9Bpph+B=?2=+y2CaqGiQ~>R_X?%^_ z_;NX47EfBS z!;)f#KLU+Fz5@3Bray8K>aid}G0~3qTVDemOYC<^_KG0Ui*~j!QSF5$KF#ZOmN);u zdg#d1tkCWx&~FrI5t?O%&4b3B<#osKbt_A7`MuxM*9 zWwv@vU^V)==1KglL1bJS^sSljvc4S?EVo+2>WtvIXQh!6ED<-~r^>&RQO2}KS*>TC zC+WwZH4o-d&^+rnc26)9FcC_F;E12{o=I{Am4zI8F5im-aRFcBiSePE+Sf zq1Vd4S<+OfN~fvQou*dkrrKvF8doYgle@>`36eHK{vGEuZZK^K4lvezI?zr-UyGe$ zqRJ+=MHONfLNEn>JAwmcO41_QlcmYl6kHl26P$&OF_%&K*@N0)tc&ln1Mo-;hMuQ3 z*7hQT2PcD@v##!8o&-B~{s0-qn2MCz1ioJhkH0EL%ApaI7N0>q`Xi22K}x z2^8TqrnmD5O5lz93wgqG;%4}QUSbMoiqLdjZ}G2$C$D{p1AwEFMh&7-MiZJj@z|C8 zgAo*ibdxYQy?+(6MBERZYt-UZj z*{kav0{g%27vMNL`8t*ITiL+vnqC&%rWmQTpy&=l>3E6PN1(b01WkZ2J0B8W{W$UH zFz}zi9eubxEuy*k(gK);Qd)SO;2SAmGy=-Esh@BLTJ15B-pKN+k%NA|NXzTIFA5$e zumyB$@?SeaO_&H{^&EiY?Zmvj$c!#dL(TiU62D^6Xk*n@G@dU_!;s9h?#<&yqtw++g$bQKYb4lC#bcvd@U47xPNL$XPgv%)yVO5+A63mZtXLD#YD_;KX z3SA_^T4CSynzUeA8N?-6JUEV5EaK2{K=#xl^Xv*0NwP}m>(@Eb3a#UkR9MMwSz2fn z^~6JCq(j+#1iMR^NvHl{pI`fsehot2mm_$)bU8S{k9l{fllGz!B<_mYTrHstX@K;> z)TN`$Lq*Xk)r2eeE$d0@5eez)Y6!))6g^zc<+6Lo?63p+TB{TL_f*XDbSyK*!n1|& z9kPam8#)`jcs?h89aQ>KCthNOR%}6X|hdkG2%W^G%gdB(+b(AT`;617+ZHk@9z zgeIY`(5XcTs)g@`BN)60wp^#kLOd&!(I`X!?iJN#zohx%5z{kAg+7Y?hGYbV$swT%T6@y9IK3x0Hei8|;XxT? zp-EYxLwK-)2Z4FqB+ZdgzNJBRNN8Od)z6IZr{CD=|mwwqD7L@lpF@t2_~r+ra1B!M;@i6Klh)Pth?H)51b?o z0-$X}L*bJNaV@)hUpg1xSW!0V^w1$KBoWKC^!Lp}9fYr6To|3g!FZ%o?j(e?3SmSb z{cF)|S^aZ8Awo}%tg^Oats&a-Y{z}3jD^u8Y8O={J&f!Gy$H5dSud+r_vIQ{NY>&! zA3U`{`Qj|2DJs)ceo?5zYrQ5x$*-pT38>@@P}_7(16W$YDQ09^7K@~iYo0wPP;$O0 z=$QQ7BP%OFq}P)WE6#|Xc|MxWRaTq&cnamRDu=Ub!atWbZ+%G+CbgIc`xKdYDlsE7 zF_+CzT=U3yt~~LaH$iu4DO0V>^?L4WKoL{W(^-yut#7E z%pjhdW(zcxLMMsf4JOuesi5U4g=FyT431rycINm=XCWFhUTiUqUu{?j2;HIX(tDP< zX$$T1p%_%(ePQS%f_f5Jr6ZURd8Ie80@_UZS1tc$%fA|7f6iC0 zUMC|7*HK$(m76)C5x%lev+&cQR9$oijMgqwC$Z=m|4~Q3cUU=g{?TvnccP`G^h`6) z)Gw}=`e4-y^l3tAAy~u-#fbo|zMTmXzTH0>Ww7@MT^Twfd2Id;!D;RBVO24oC>&CX zy7Q+RdWM01e$Le_f62rmlLaIr5qgS2dWh>9en8exJHHNJb7+s+cday|^3mR252x)< zXzBYyNu54loz6z4(<6_1?e=-tQ7?MCEU}`ZRXOS+4v~NrLeAUN0tAGD+)`hDc4*8> zZz?vxM%k=A!3za4{t=$0T{`LPP-fX>X+cHD*^5xz>K{;}KJgS43YJyw31&&=1~La= zf?;Jdi&cmX^y)CY9q}Y(G{srm*sc`$L4UK%k`An23F`YPF=9&aoCko6=00+W^&g#< zrPOp8Y`(vR@B0nyNmKy`q@;euo)o9j98z>%4|yHAi#rXU{#eXmX>C+ChHz@S@Q{eu zTQ-jO29c-Ey+PEMUWvWIaDc?Re2nE7w8}oKp~>vC$K`7)^X-Qc`-~e5vbsTWylXPK zr@Qs>{5Kjjm>w3-|1NjHs=H=OTVuZ#*aL56KKTMd&H(xGq3j&z)pDjob6j6E8ycl9 zMeXGyS>~l)y$pP^`t#{lMG6+^q!+s@!7f*0f99~)!4MBo>6naDJ9avvR3kk{&e5k(8JXiBv&2tUUHD>x2lIlq6GSk;<{CL&M6r2s5hJN6hRC=Rszm)hlhpCybw9l#k zl5s@sN#xtn$~sM^N(tN)s+T*D_=Ghp!)5jRs;Q1n^#9P}Lk`orKuKF58kP5f5)Ru( zq&;95BM-tQ$*#}J^R5h}yk`$Rn3g7wg;Q1rvfjf*#%7|?@r|R@+CnJt)X+BjVp$89 zj?_bji-VuT^D2bNwIr*4P+oLOA=cmS6NqM~_}OS~kV3%w8Qa|pAy}g_SpwhGE3VQY zvw0MJOVG7-P^e~MAW~56-;g`eAK`R=Fja zmK2jJCE>WbkV90v)A_%sNAqaDp&o0;$%y54s|y$oXdkN!{Bx9g;W8PQtu7F};D;I^ zZlmi6a6_4DtftVM@v(HQLaR+;E2g)JBdFwbc6vGI7^*bEO!e^(fUD^YYVY7i9@VhX z`NV40s=m3iA4L83O7@E$f0n;?c2qOU3CqZk&yBg~p9O-g!3};AA{T@RC za!L*vm)9Pa(S|U&-}#ijaXe_~=ahT~B}+NX6iN-+kB;E&8ZxR|XG*o`t<+E6`zHnn zTZ3qB#>3PQ$^8on)VGQeC2_yZL?rVGNsQ!vpNsZIAh;g)aL}JgMVQ^w1@G@~;MdeM~^YuFSBv(h4WC(1LLLP7o8eBv+SDG z;AzGxF9*X=PsfsBCF`SirACJp*9R^r$VmU%EO|BbPhq8&jST%2jmc4Kd-%RS3*N^@ zvt(Q7b8BWsL+sb!z`?UofC(0cW4XcOJll{+U?4Y^)9vI=mKdDG%sjaPt;me;=LQXr z%#XM+Blk%^5s284?_|Y}Xa34h-1Y}p_)T9@lYlcurGLNPohvBwrYd@o2Q&RO)`j;) zfpLN82^IdFGM*m` z+iyFhiw!!qU7g9DAOzU_%TcoePl!qSLbsU-eW8SJTOftYpss+P=u zI9TG$JCc_h&(CM25{AS%u?9lUY>=t7?Ar2DQSHIdKHgGW9;_7JRdhimXZA+y0zxUF zx20cYW{E9VI7J)N%$;9@x)JD#1nf^Fy%6{~@Evf4d0h~YoQZIVAp4%c63qUAI)^aN zjtZj=NjdgG#u#;Kilq=;td!@JCRh&pMy-8Y6Gf1KJJct{zOl2ZLUCilfRnNVl#MEp zJ1z@^IuXmrByOpLlNO-ZnAhJ0N$G@x*6SF4iQFJh4MtJIIj&-#u^rY;W?=kQT(w=v z(!s>D2?lK&FZ`Z1qwz&<0@iu&{R*h(Ij@^b#mf2EOdy&K9VfK&0i6MEQRW6-I`ITx ze;G|%C>B6G%Pc?dY2E|_DoywVjMYi1`I1Bv98TO0)q_nhUIA;J>XtgyMYx2POD)TK zYneluJ-?#yL!+^PZKb1Z3bS!C1;|)tP9lT)6Hhd|lzZXDJw_wWl)}dM=Fd&!A13+l z;fXw1+#8MaSzCPk8L}ejNh6dk9Do5h53VY~Q~f^s^eWb!)gcVO-&P1f46(G+z4ena zCI=^b%O++7FG%A2?((xATfa;<552+3w6w-wetz&eoLB8rgQ%6B1W&4pOxmaEZ8xip z62EU>mOp}%Qyf8+Puv&!$h#&>ui)J>9^=Pr{20e68!Z{sH-Zby$cbKBY|o=ad@8|~ zmIH@6qgP<^y4$$-`|`YozR2Ggcx6WTZjzjGrO?;UmO}BZpz0`8cYO{Sq;dX8a393; zdHa7M2U-sSjFuXWKa%#qNyS$d%vP#KEpoTXE|JX7>UwwR`r){YP^0;Xsd6#2N946^f7r?Olmc|=W97n5)_hDhxaJ|! z?(#7J8acNecqg0H@x5EBb#IHgoZ$1-cI29bNTs;r_^$nO5{a64FtPFkxPgWeaIRpEp;grHKdvBaS9 z5cGq(saKhMkb}}xXI2`LV>P=EoxSvMj3@~#1LQ7w*VYuH~O@0khm%T!t`tx z{p1AJ zwZ>zQTwZfGOo&G>9jM+tAC%VGZ)Ls!=#rufJzdMs2UGdO&vCg^K52h2%^s^BVjHt= z_REsUj4sWwhgq2q@IknxB9a-FFA12|x)!Q3MJYI{A- z+F9D2HQr25xn_aHl+^hy`d9hNb-rWlp+a-sUOd__^qklO=vwq`5II~vfBG}+IfmIW zTR)=CNiEcQ@Sv|7uU>ewT;5$A4_>U^39zW35>5m74KLXf986rg(Z>iECQR_c@5m9C zanKA0_*jhdRHjdkAQ@-%x2cp=DEObd3}miE89^qDjm#Q=W(a@LgJZD&aq_B7T%FJD zne^aXPwph?!5QW}iA-Bc4^ZO~-E+Kj;TzNqMkL{pz|wpj#r6qmu3OZy-lEi#qg>zw z!617rJo!8(Cnc2KmU+6|Q~;p03|lnOgh`-BjpJv*DOWowCMiF3QYxL4`K0{PNtxiJ z)RFS2lX9|?vXqnuofO#W47OFz@RQi!BpzjOkN0RdvC$U2knH(L5 zum8I0vog}M;tFKN$S=DBC$E6H@kyY3ZG{Zz7;a3t8Ll-@&$|a(88iA=H?_pB1XYu&d8P>=JC*xI8GinuCFz91C*?y!OvR~XyXr#yht*vJm`H_$=_h}1PV%)2&UMj~3( zCBE^i+h|R6W}$cOFi90YwPbYOf*h1O?~A=_wPr{E_k;JSJl+r9Bl)QV&ix2V>8*+K zyEcIztSyk#=y%F^BNDMf$v=1x%Ed9YLuaUVn>2Wju6eU2fOoc0Nln1g^E=6}FY~S?5JPVZd3|Z}>&v}sL1B|$m%6W~UEy6jtKTc> zgBqIr^_AYWSM|%HKHZqqv{~M@=$|GRzB~E#Ro=BoC6ix2oBaA}@7gQ+zkY<*eUq6O znE8o;`A`LQ20gEOyq%$~OJw*+U7<7RiA~C|G?C#0b*|1JbLz~PF5$j(MzGN+E_0%0NBtLrmJDyscAciCzpA;!@5REro#Y8A92fXo0Qc~%4{d4hLk@zDbplHL*gT7 z@qUI+6W%Z*X1l0RM`m}J<&SC5JBAw#jEDR1_!vF!%MdhX^!FMDp8~z-#mfu?o&$ro ztLyKU7Iz5>1MuAxn?)8q<$>rQP!hB z!}4^t|38(XbLjG=m_!a%t&`(3^YSaY^N{cm~`e^?p0pfWPC$i9+|jJC~@8`%bp&irZ-M=&}kR_0-Shf0f;dC0kC zUu8}V%KK^TtITtpTlUoj0sM7YO-csH-BG3$?bMH((fsb)QTcAV`r&eEd{v6FxCuml zBj4g+Ir4&h<&T6|gHUs@yV+B>v8NU#?}GfJu<2dri*{N8Rc|3Ut)1_6u`O zC<=Cl$SRM(`H#d=0@gFtECJMzpm`#*gr$U8bho;(nx+yOT{>?`5^N68_D$QzwU7xJ>s;+3#LA7W^5 zCHtZ>x}vNyddFY=(dUagBy)87<9tX%a-6a$NS{sWem>T=&9K7AAqDC-4(?J55>@Az z(fd>Q;yI~TGD-6=4Ury9*O`vp12D5<=QVV3Z~L%gjQgXF+KmH+MVG+}r#$SiqgSx) zDD$%yq|ed0sgkXXijh(JqIc}o`P@bd61J6md?w$Jec4{g{t#`nUQ0AmJ)w(|9P;u} zUQ$-#ElMfP`n@l@?4Z0CpqMlR)S=rm&uP!HLy|{829+ktNaVS=Uq!O0o=XQRP+Owa z(&CYBbu$J?QM1WKIl|aXEQs#so$1hBVixrfJWjJwLrYYtc9Uta?$8suLs+Ksy}af# zGHO2@gTXAFUO&~p*OKA;l%RLpU_2|!ep@7=297?)ga$VnMH=94B$x)G%wPC|P^@f0 z`gHSG0xf5haeFPd(NL!KH=gTMK)vJmW;Sswp8EC$f`S> zdl^7APwu0Z>RPx zo62zRWq4Hg5}il(yZS)iYqo@FCWT)vboF87fN+d2A#I5NRK8Z48Nw&!iF?+-f4*#8 z3*WCLEk&KC3lXU;);A0YV&6L20c(cGt?Ji3QXh6eJJbqtu90u-QzvY03t!KzF5zZf z!h?l8s1WoH+%9AbJSEY}w9U~waP%Rxje0^^y@0t3@eijTUaK_;DvGB1aM4sBD(uTM zF|!Dr24f1f@Ih)m%7ZSy?yD^t;tEn`g|5@ziBWPr$b|N71deYhB_(Si|?D$85U z<4-hJcgWfM3)uC71LYd4r()AZoJk%y1GUUzzhl&u)QUvu?itiq^kKK$Qxf($y8Io= z>y|&NU-=G?(>>2z(W?8@703UB)zC>F-6NQ#(a_cZG3kJox3aW)Ge^B;-Zdg^L|{7p zI~?-m)m@@Ih|h;zf+N$*rApg`RCo6!wG{eACt#~-MPxO`?&M$MobAU`q&h(l<)CI5 z@z9$4@NHCr_0jF774CG~d86=VuV;Tc4c|-zdO{NnRkcCABc%j&-$(l1=}T`8Us8?- z{;6|Fq3X<}^g?|fPIP;^R5pdmvSb_@VglLJSBvzwc_h75Pl8!OjBzKeK(g_;*Ljp; z)Hdf{`mRI)-HiUZnEMx;fn0`COy*k)WH6_9$<`O=vccn|Pr2%0{pk?3Qm)~97+a*} zmom0QotGS$s!qSz1jo9q(BwD|Jq@&QR+Z+BYA&hl`q(sbIy_PY$CuhOew%I$kGi-yI(CqDG!$cef4Rl zCA)&tWJJBDMM#a;L&(qDY@$e(Yq~{FL`t${3ZCSAkg#&0HyQkrTV>nq32Kqd!(_AD z`hf*Njnu=@)bN4cMONngT0RlAhQ^{!n%m&d%V0goqzkpNPFOOkd9mi>-hHlLe0+(v z3gLI+trE4`3?1Z-({?ronpR|SJ~^;O3p!3Vtp{|uBCp=|JMpFRlOktJy(|rwdz53S z1(}YVBY8ZA`dLggNrL{s)NZXUpL9v+5Oi4hi*&G&h`4Z_iu2YMX;B3&!ba0-({E0Y zJfVSWXc?{Dqf3o2+^f(kbSu9&Q=i!A%x7jUA!%$TC)S?|Im7eszBY zGr;qTZu6ATL8NZ9TH5R__&;p#P*|C|y){6AgH!V|j%=7-53YSRm_6EP4Ii}7NocsL zn|hbVQ#vK4UR)sLY6VYvuFdG9k8*F#IN=cV;kMDc8s5t6ipLw)r{%G1UZ6^?p&c6H z!zfDwoY+asgyw3XuTrXBhqopEH$}=QB)7OHjb2Ku6{mQo$TVGKsucNcisXoR3f_w- zyp*cPD1d1IDvfN|oIz)C`5Kv#C#!Q>d9W%a^tnCzU~5`vp|5<=u;A%|c~c1k$A`ka z`NL^iFgz?gBQK55lD{cps8T~jTG^(SQ7BcOL$1{Rxsn#Xwb5Dj@58N?zJ%FBm|Lw) z;p1_wgq+tQXz88q*P%Vm7`j82)W4MgRKaSrCQ_o0e}Qo)h3?S|AYZk&qM{sT#PrYhLTcHGEL2;a%q38+%u~oYsbVfv4?TpAGMg*5nf>R4$D$&<*DM$5Hguh5^50i}z z0J60?xT3cFoZwQ>x@MF?)c>BU*ZO?Xi{n|&monY<;Q1uo?k1h$B#k5K+iucA{bA^o zb%Rq<3hlEjjtHRHicGDg(x<>=r&H`kpbREoW8MKUO#6*5=AxM~&Pvk7moSx5PzQ&DJy?JTNJzo9Pn&kqr7 z>$trM{i(^nkn;%h2vC>`%>z1yu9D+rQj5)rl_>_k2Q(nFK5N>w)Jt6#`z<4yanWNX z>vwjW^WcGh?r(iJV}>>CRP_~%Il7VSrx{uP^zHtLVQ1f&8C?;#)1#qO&!M|t!iNXw znn~kifU0{X$&QnkLdWli$Qku{C~z7kwk+IaTRCka2et5pI_VYxxgQ3i_t!HxCaOXX zg!V0Y|<W+lrT`8Dj(*k zkDc%94)uO-G}g$bgVrpdj`3m>UH+#Ol0pP`|NEsJ-UTjiNnDK_+VA+XQzv~5_{U?X z(Rea>Cp+qt!@0#GKA!&*zLR%iNTZqiaDlbX%xg5zA6+GTO7O-zxK^y0J&oES=IKoRLZ>K&j?DP#!Wc96juS#tAbz16Yu`&4TLglOqu z0)%va*(0hZ&K^wi!2*gPLkEg*2E>DlJqlF>P*Fd=Nmh+gKhRf5k~NQW2&ya5Dz>7~ z6V8@BwATTwR=d^JA8m-|ik!8Q&JjEsp+O|>sJ(S7Gbt>UVF2WO0Tg`m6t+{g;{ zlm>^zvH5683xAotuq$k2M3!VlmSk81lMfW#I>4v@rw;hkQ?JdBBug? zh9I6*Ry(*_^r1(k309f|zy_9tL<2=1x-b0q$$K`|}%M(!0XA}CHT|05jP8(H~eqMFq~)~d$mKMIRyc-& zjX%1?BAxRslb|6P#K-M)ImNAt*!kJc>MWZ;((KCUCI!rkOB&^ z3>IXrgMUWmW&q{CB{*k|uYB>a;CX?0(=^UmXj(&5`H33ADhwNF*lmo=g@PnzL;`v8 zOdA$DgA(jh4h~EWAs`|GZRU^-vdRmBL!q-|m4BgEc`Dyp1CtO;F&C!?&TxQWE|uq_ z`jG1O;Q`)C)p{VVT&K6xdDcLUTMne%1;H%AuJEQ;t$P8Ri*{}VDo?x>obfxuLY;b1 z+G8YhXrj(^c5jJkPKlVJ0SY)f${IiB`su^# z;`!T6J!OMV9_YYUAm@V`7U;1nSj+tDf>;BCV5FWOy)4xpCpYB}%9aQ+DoObjd=_$! zOpHtgi;0mLByfwRBa?b8xb^)<`;7%=lP=l^dLD>+(<&$I!ZEsi0me%ZvYAT;uGt$0 z;tz4q_RJ+&Yrf#QHoe1(^GI*FwZmAw1$JwmFMYG0MO6z`{4&hn{^NQKeDMmw7iWU` z&2C{wE;~Ut9&a`IH9QMqH(w`(PPQ)1@}XlYqg$%6!gzkube&schc=vyt?KG)KnKQ? zRcCV$L5&l}^JnYKS^<5Cpp%T*fO!5cQjbI@fpZ#f12J;qO=}J+#u)G8Lj;^C`vzuc zhc7xKt>J*U-_ms%>tflmfZ3E?*j-H1ExXpUyr?u-MVt}5H0wFTj*U?o>c;`<(F71S z7(>12EkYeZ2MLRUjqEKy!J&e*BBedZSu<(Q$qN>|Afbk;Ir7KA>%^(K9(b@iadZ*` z&ph9c$MKAlG>(a1WK_Y;*7q_@YuI@8=qg!H!SM(kHP)d%vXeCA)ZA332Xw_cM_(Yr%soqh`;&`8NrMsUh5qP4U1@`-iT6ewP zQS>NM*@**w^?OOsjydoY__N1Z^Jb)34t?;JdY%H2ReHY=>427=1Pmz*a$x3vD6B%_ z`9XZfw}3t>yi*f0=jKk+x=(*V?z?pEprD~V4b@MO{#Bg{b<((vM1|X78V|j>(`b58 zD!1~Fr^rB57ZN8Rc7vW>kj`^dd2x_YaX&(NFH6x2+&VAQbK~UvG!0z@CLl~EiQE*;-FXoA`<(dq3Z~;8+rRN~3|4k#U{z1&?Bmm0XD8nV~0VlG;h9C5I zYp5;dkKPNi5B$(DvJLPnxhu$dLbQWU^U!BR*Is0(w?~TXCWoeo>q2n|maR@JkR{L! zrH3P7c!_ULc3q#(wM1UIn&DGYL@4r<*4j>f z(% z>n4non|&Z!)!X<01K2!#KA~jP7JAbSwWo1N2Ef&ZcIQPyCD-*5RgZ+_iaeqvC?$mx zC3*HsfEc)*PQ<>1E=CgF${3aU=iwE;m2Mnrjei!8hqBPDW)ed)MQt;qDSi(ct4qDY z(1@N@ybcEDy0@8P;vZ)N0lij-5ZdkH1-WF{>A}*bT~RacHT+xREls<8)=r<{Z})jN z-@U_uxfT7uU+LTpO)X3RVLs~6cj+y>-3Su4O}#W)R>&UQ*bn#YUjaFe|DTOQz^(eV zKCv@}6#3&(u56x1t47bIqvP5~pSy4zs$BRiGbX%&#`kj<^~7J4z5vX3x$3vWd-bEIpdWp@WnW#P^W`#5z=@8{}KI0ZCHFLQArj8N)>V)gDY-GL(P8OrpbTc&}O@MKC= zIbcB+kD=WOXMz;TT6E=O*$*sns$LSjGf$#tdS4L|!5MxDLM-+>v zAdxRc$)UH$$HwXr0f{Z)563a^Z->hfFs9m~-TP-3D&Tn~cy+*I!vgViFPwt$s9(a1 zZdLCW%3eN*^o<#-Um8z=pAl{Yb^qATaBg5f1xk9%^nC&{itQgv_|S~bj{8gg?vH@@ zZLsIa72LqSl4j_>J58AIhB{Abm#V>qL}ypVqkehD_>|ySUA7EVK$r=5I@-h6D#QIC z^jCX;_~uGymAbZo-+j=Lt?0uIc2=_crCz|I;fUVHxYp4A>M%Le{^~|BWFh|T3QcrY zmn%6I4S=yCYdVp`B9vFrTzNl=Ar7^VZGV_mfe%^Qr9c}s4CelYI9-sdPzTd z|Ei4aW^pf%XPDr9TH0^hlaurTcn|rV$YM0k)#5qFV;!R9eYDsg^~U{pHD>riY2*|y zlVv&^wH;4P_|ftHQh)EJ^c3~`<9nt4ufOlG0sBk+v7MOZL0*mC84h$Aok9MHbC7Ki z2@;M#K0dU*o_e?+YQKAEeF{iJDBE$5@^p)R0Vye@j7atq>~~Pyr#tNedEFTgUC@9i zH7{k!c&~OK{&ZKBwRh$E*7pY#U7S--B(LNB;-TQf>@9>+@}jQCP{nff+7|}_v21ST z92qNn6(-2ZY@+t~rYX2;ouXZ}I=&|Krkv&Ab=7*W;R4(Z#3%^QOUH>h-7GcX4X^fr z;BB}oNAsFaH&$2Wd81S7#bx+aIGlv*bn1gZ z7hyh(M~%#szFc|6Dw^-QtsItRo5reL_EdlQf0uFg5ezyq2WCzsC;duEz_&x5xJ>32 zjZ6I>j-Ti)saJ*y@-qu*PcVaPVcDE+(L$)|bX|Yo%R?aJd;m$c_}=N|kv4o_W(YLM zyvy%`k;bAtQg9vY@J<8hy)wtRzugtgR}T#BUCl43o_Orcbit+$2H(YCAc(W!SJW0- zBDe@U)VrpOMyeW)KuLK318W-YB+eiasFP;g8za#lNB`<4MHN!9@uwa$@?=q&++$Zw zH1JYxg@yloQ89PgP+$U}+&izRWW2w-}cy&)17@o)MjRw%-E5>G69G zEh#j{(81jtC*Js9g{!>7G-ht~r}qE@{hs*Zw_#l3&dd)waFV}dzcI$gSc)BV&hf0W zX7Tr$>KAp5_wjv3`AdE+u%*z%F{Eyb(L8`I;DYHDVAAuiNGD_9{c&@rKvKW)r+t@1 zC&Au&O;>+6PX7gU40t{c7A5azfOdyjvfEgd-AuSZVVP;yI{%QSS=*d%OP!`x@$D&9 z*0!pW9mbe?dM)k6!FJA2;tUQ=YO&G|+?;;jJt5K0c#xxD2Osz87k%^hZ~Co6wGV+9 zE*|X%lza9sLP&;JxUEi$Y+C*jMIUYXWM{*r^H=g?v&eY^hT9%XtyTPTX0 z=yU~75-0s7+rO!P-1do503LrqTw{x6R6SoWDtO3W@{#HJcriE|^*MtRwC#M7{hklq z>JrH)_`*;!OSZCJ(45hex4b0a`EXG_Jl$7HS#5gKAX@Z%(h(zk5+qT;vSUAhjZVU% zd`<}FH{#51A}fU$;m^ntu)dDX=PDkjWx1M`vw}saFRR+b(Y9W^!o-nh7_NKn2f8-A zEc-8UCMDy`9Ojw-z}CR^tWYRR60eXJo<%Z>#KS@!C&P)o^WOr_US#|)?g^%FY+TN< z5qh5`kwrA+akUQtpXv_`#GWhNST!tT*ZT+83lq&)Wu~&uFh|%ghnFmB+EpR#3cp;2 ztMk6Zl0>45e<$pg3a$=V?CtZuoY;dl^;=BH>;970#l~LLK}_;Fd5Hxh)Nt@ z^6&iA9;)@vt@ZwrEv%6WtURX4 zV_NJt?qj+_gK5 zn#0UokymTnv7W)%;0#XaJii!twaa;tC#V~WQn$0TWvn_X%9at-L@4Xz*E4x-Jl{?v z>Jstyna5n`Em`X;*$ms>SaRnS>wyR7Ck@`=RQqO{ayZStK`!aKmxnX#YI(}E{c;&# zPm#+&+as4Od!k$h*=NZm+dfq;gY7YL$*~LMl4}o@%Me>e=&rL_$A!_)X#G=U2_| zYJNBHyP4ktevA0s#jk;1Gr#Zg`w_nn`F+K2@GGe)qxhZ9?>v59epURg;de8?@A6y0 zFT(E;e!t-N2YzR;dCuWi#_wW&)A&{KyOQ5^{JzESR(^H-mhiiqUlYFv`2Bz%@~aq= z#~~^{-yudST)LGbewg~>px)Dcf2R;Gc8y@T?+IJrQysAq5TTwVmjDawHm-<=?<9D7 zkqIx!b9hNMFzTQ$Yh;EtAU4@b*6#3uRI_9!8II{DLt`b?KpUjYnlu^>)0jvR;V#bf zB;J5l8`dVrT5G{Y*lNO)7k-PK3)M>~90||nm0jv)?7RhIB1@NgSwB>EI$CWavKSWLoEFiZi=IXgqq4KPs@u*m zR#idi$3w>fWe2)G0w=r?+sz1r6@^OF^;x|m8r|PR06G{A;ANGaZe~Oz@q1#wk{JPu z>d=pJ)*h$E_I-H;U)ta0E86=|sdSC4NT`=8MCzQ2xLeq+JajuzdN0<8d$<`^1tOLz z1(wK>yB!Arpk-P_i>$m@JMZ`atQiU+SN&;VqOl0!XZIwE>uoFtF?*p-l-_ILvcqX# zR#@do2(^FngpNQR{N|;FP887S{9hmweVh(zzsCqmKEa#u2yx1}Vhjz#D09VW{Kk7N z>{(V^fM4T_xxUBmV}6JDN%}z24RtOJWEgflCm4A7?3@t3I#=x11KQ>eD8>Tz`D#VL z5hWb;y3beV5#M350D8Sdcw*66(36b52)~+XxZti;ZR#%roXVx%<8{GPXiK7A`#hE9 zR9bLUrOz>CDK`E=kEqjY?WeiA+UP8Nb8J^p-N6-yn2w>W#nV7<;`s%o96x((*r@v{ z!VuNU9m+Cc2$!w6SiDnJou-!asC`FL6YeN_-CZp!b8YHepI4at9mR)XV!T#NbFn$I zcj;=D7u5uf+P1W_AUZBj^I}JGXfGk&LA#?1)2vp)#UJ|IY7ZYCv_|YoebKtTwO(V| zCM@x5iJ{_+q`}z93ZS#^*}o9buz%r5^eH^53KhoZ#_|R30apCI2loK>I8+QSLXtp) zo7IE(5>z{u#x={2@TJPry3iHP1E|mjIf7U3_)#n+tu_p2Z;=mfSk*(@>W)S*8%Rqp8H45WN5e_gY@z=Z1+345gZv{XDuzx(3rB?v!n zKZESjDo5T4lyiJ)IT%j3W{;o<>`CiW?cFhk!*@z(^Q9uZ8F{*ZSGMW56wbWV(sSRbCxKOoT&8Enn$oErcVmLof5pxs-(b$h2OK z=l^f9)F!ZOwsV|T>&cbb6Fs}cpT^IUU^Vkm?VpG9%WfS3rm|_Xgp?IDU7ZXF^K5_# zLP*&?PAn?1m~(i`!djGO>mZtPm_aSmShiVXQN27$%heegK|0b&e6`3ZWF1(U+ZdO4 zhwxEkkZGj5K2X_*Ei}mA0EaJr&*D6_0Eg4=YWeBk`ryY=LY|5%!jo6eX3O>RT0=Lp z-h$Ukd9&Q|mIMTPW=v?g4pH-}!NAE>9Mq+=F;fLzjy@7zT3bXp9T|R0p#v&MQ{o7} z1o?RBx((OGrqf7f>$;d2E6Ymi`*X)T;S&z$%3^CEqP5MTQ`C=odVAIOYNA)5LVE68 z9Z6~U-^_+DWgwPp18o+tFZfb&rpj|$d>k5O1VTv$l`F!N{|EgH2UPAYPk_o=b?Zg{ zDX9D%4A&%3nbB}0s63vqJl>~LBig&AZiGF6(WEijv0cDw7Uhy&d#Y79epw77;hxkf za164HRnz0#s^WlbLZI zn@mT7FE!`A@D%eRI-1sRM3`G;ed3E$vSKk>orPQ2o3oHW<$)4OAmtfMiO4bs!8tb` z5QQgm-d|eys_CHQ0VjS%ou>12k*9||`{2v@tQXp)4p8=ii2Hnm#YWPbB_7{I&l}H` zI1{ccHilLfczTS+|Hs~&z(-N6{r)rAn1n!vJtD|}2w{(c5SH{zAm9XoL_iGSk*ttF zmN5$iMG1=%%lc%rfdWx3B&&#$I?hH&(K-~avG z`}yC~F!{~5p4zLry1S~o=S>R2zv6i<&n&JxZeQ)Clf&2~ep}MQfqc>&v%ZSFP`1Xe zyDT=OWC%^xo|c?Ycv@M%Surk72;*>X%hA-0>=8O&cjrj=IqnnzwOndJS< zr53w5lfTdlQ8|bF+5t79@~<7!7ZC}O0 z{9ReG;|nM*NgU;I^cyr<^?rpzCeg26(AzQIZTWT*?T4FYw2mMD!vcC`$kb|jgQEHs zGg^J%^(p!jPbctB6)T@gxmr4Tjvs%SBdKmn8b4N|`KylR%<}M-8UlLei5A{w=wEdX zZ@H8ldAylPKaTiL%Vnih(oMNuJ+G+VxX%yf+J5+4-!F}^E`zR|1Adp;)AH6~Iy1-b zEYmzbA0y~)0RCO(T8cq_mzi=+XIAt$IJvNgIQq^jZ0dLtbwvFbbGmx&k&0^>8hm`X ztDwV3hV^hK=Lz&P9W+0oI(PDh@J@6QA9FWVkYmjro6{D%A#5OZo-lerWHc>`lSBDg zqu+?J(@z?F?ecbP;$O#h@lfU(7%?fLJch1vIkOwWU!%j!4;_-L!(XH?bpC#@!CrPY zg}i%RTZdIcN54_uf&9hXJ-XrGc2`-So#EG!HyTcCJHyxE8|Buykk*zdvNCcKG>;wp zEj2r75*=DnL$~o2RLtKz-RaCeoyN$9*p$$QsWgdlT6J1<>csa;qUgOVp>L*6+*Q(< zo}wZTaZ@M0Rq}Pv4|=KN5$-FX=gkst@5jU4do5!qW3-p`<9jsJl19r~+IM-!i>~$z zJk&&|b8;iUe}Pf*SwC|Do!*YO(@%|LpErq~>sm7*Z7LmbVn#PS*OB_g;_=gC>E;|N zBpvhhb-bKI`F~@IuJzBOgT*hjF68CwMLLCgmsU%Ys(X9sRkA6epQUb^64tWON1bPC z*ucdHch_?Z&<{p^7TR>hoUpPkyy&22{rRSXH?QRqaW>7nO6WY+OSLPnEjxKWQmW^- zlMj`8bWrM3Pkkfl(5K0vjmcNc2+o1`>VKaD?ol+8K^>6KcBpl!bMjd}rA>P+y)V^e zv(->``Q*lIFEtnSY0D3^>U?lY*kZc*bz*jDVRJeESR>C=_#39>LVBkqy;8>2GDm%> zh-(=%gio4zm9TnSGQFac2H&J@UpvkYXG{dneI*9Mk!g7@a>|Jx8aQAF|@xYw$k4f15~^;nY=iroZ>5gRifQS zqhQ~9CpA6I$R>?&*{so^IzwBd((ns}!)`TAtyn>tzQcoaRQZr#l5vE$8F zcm3UBKVw2a|HX$kziqYm{S9jZUsg z>r7WqbdAU!o}C^=w#8&juJT50r%GA8!LhxD?uC!}+vG5|M{MA5o-ndUa5x>WB}xuP zUMJJz{}hcU#7zI$>CxhkLPzUVk)Xn7r_-BJZB@0LZ<*VS|Ft=rGt6iqL2rKX(a|Ip9j=y%SIAq6Nmlqd= zG_wb)`j{)XQ~ye>raN@^^rHzQSIV$AQikoC8M@8y;coJP=whx)M05Gui=vF8&uka{ zS>T~RSsAY#T^&iE^IY_2zK8x~W{~^FN{WZ{`dZOj8$|DJW<9!kL#60-wW7B)h~Cvq z>ZRYjrIfvEUS&yH(;^~8SXV(K_smUR%Kx5by0;-^+YjOARNsDUn(9WMB_02U%Y1bd z-70aMzOBAG65q(p<#)q3a`X7z@QvIu{BHPGoElZhk)=km5Y-B?5H$!XDX=%cc5Jon zwYC+s=0P=ZVtwtU`r6C&wU_H_@1Lo!y{NCfsIR@Kuf6~M`YLO;zAoE)VtuijOKQYl zU+flKU+fl8Uo;(UsV^q8zL>1_74uk|sxlrO%<+MHqJw%kb?j)G3ZssFD_tql{u09b zOF>90d8niw6LTfq9D<{z{Ae?E= zAw^i;N}6<*DQ`HpxayMm=R6wYUh?trUS*g z#2II(g986BOX|e%X++C=(wC|9g%1i%6V<*$*Y(GDd~;cB13fK$(nG-VTnZRX0b{Ou zmkKQf(EW!-ZaaOFXz*H{M1$ArqzwAAhMSzV7TN%9CdFVLIEt4(+s+7Xdy7v5FoLgM zug7irhS7(9iE0Qx&vc%5)XDsJlG}0^B*4Al6YWC;(;wm4{Sjr+N{R09HwK+-#&?Adw z-51wvv`+}@Qa+sSD@r-uNN(jn$)FKhPLJg_l*NcWTI}UNd+Buf)P{AtkJFjgwtXRG zi!wuU5n!*X($Sekrax6Q>v&O0>Z^g|+L zx9RZo`t@ye>)9LSKash^59=8HpKAIIub4(}%o}uvjHDh|T+8`3PaV;#03PIPYg$OG z+32JvfY!fXwrFdI@?TTxj~`Rp3$@yHZa7psa;o zN<-n!qu=>C$Gh!&Cw(7J-$&tlfBN1_oTKO`i=OjtN_HHlM|hGQ$JF1W>hBTt_jmR8 zH}&_h`rCHW>kVoj)iN>9Qo}@*&!UQ_iO#9qGC!ugP>C(&c@*T>61oFlT^l8~@ug9t z)Mr%rD|GJbbGoH)5Um= zm#1>o##i=yp8#)x@t^1=&|ZCGCB^VxPXBmud+B>OZA_=w_RX9_m*1N^T=i2?{O4j z(?%D6e}GG}Ny>1}Y)cwySuB!%-SE>Nx#pz3CwqQ7r@5%H?w-Huc%?+`9zvGO0B-4Qn{XA!N0!v9KD~Sr4L84)8iv|+s>&TI%OcC zr8b&5otjLU_bj3{>l3p1-RkzU`7XN$W%GG)%WHXpzEsoiIMDp2moo6*%XBnndI?AQ zXEH4-Z(OzUm6y>>Y5~s9Zl=q*aFt!nUhUX0bKvNPHHUeJ<0n|Bx@5-)Xa&x{E^}63 zGoe99SCgIS2Pdm94mdkk9eKUkot;2Cjac*!bIM(pZ&*tFd|}>S}=B znR|{jBbB>jfOF+#KDr-KJzvxEDE<8K34Mza%F_v5O&-iDQ*T<4yp;wT`20W&3)rAG ze@zD;NR&taeFituvn_m%k-8~-BY)i#{?w^9+w=`#w5x|#z_{tW*2x>@+K-U6oUGmr z;YG@CrzIpUBk7>b#h`mZHg$T2T=vDCNqgI-PDA*6pBd`=Uxv_kCw-US{rO=MKl{lq zl;05k*-%QC&X%e@PWt_EY8k$VgHHzdjfvGEYT562kGGZKt(Fhp<2||WeH@6E{Oh?m zmU~n#Q|@n+4e`f#0|lgq=r~5Yfx{uIh}Cwwl0V*K1xLy`m-{Pz7(}@qO|zul>ga8B z`b?R7v94s>Gy;VhfaWcp%+3+pzEPE&|2uz&>hhC zpayV3A5IWZ|sUIgH-!(hP&p0 zb0mDDQ#2k*>+%v0v;{i6i@3X>4rq6%j#ul2v&DaRq~od+9#|&%Ony(a`;DTWuS9it zt&Ua+SMZ70=RP5`ii=$Z#YIbOws+c(w+ZgPp!`j6 zNruwjm2koK7Pxy5&WUnm^q2D0^b@UxHbC=>DQCI-lX0?Xc8Rkqx1^-FgiLwwwVy8e zUzC+unmb_vl{_oI%vG9O#xa@hi!<{JOoQp3TfEqGwiRbBE-%f_EX&Ptx%r7-RgVP) z#pEQ7(bRr@Ri4D1^S~QlMaI#GZ<*l_j{>ZGZWBu%Is)4|(IET%Z?LFnj+#TQPnSWbH`tUDAaol~Or$Jq$?7u&K2IJF*^ep|AtY?!hAstIvNji>{>n4G;lyp3473l<0u8WDJSCJ-?t|fJoE++Mm=8z_l=8{e( z-@m2@!AZTj@_XjtFxh{EY19M&T=IAWxtHFxc1$MEK zws6V|a6Rk@Bq)w8eoVz#cG<{b%L88_ zXsZNw0@r}A1aAdj1+EA4ae}ud@IXOZ3z)}J-W=T|zXJqqap2Wp4|oGO9b6601M}F# zTLrk6psfnbV=Zr6!Tkhn4d4=R6L>wi70hF<+PX`AOUtvfb4yEYnK?Nnq^`x8h4}?^ zvQ$iG4&^>yaS5FPuzzjOFLITa(x9iAJ!USaQ;N*20v-!93+U`6XQeB6c=XZ(;%SEHzZG-yyC_A1-Y)A+|ulld|#P5 z3ljH2%6R4yPMx@w_L5vW6_Q#A za>uz9r<+|;OtqJjyF5QTm&#bA$6d;9S$>f^X>#d0E6KgMJikO@M2O-N7o}TVUP7U> z%1c+;a>zqA6;hfax6oH6BSmgSZgzPYSGH?$aY@NzsfMX4 zn2RzCb1hXb{>qE8`HU{O#q;Pq)Ky+YjhUT?rd9s)bEpyX7w6}4h6{_A>w3vAD9Bxs zS>VcAS(Z!ZoEMkp7G-k_P}zM{tG<$aI+t|i7jwrbD=98;75j2a^tq(+S4O9{r0s4(S`N()>$QhbYP|TTxuH zjQZIMb*RxywXaT;H3t{HsF>Pi@nR}=sV|dCMx33OUy#FHM(sezAi1m7XD!ZN7O-!y z7joBGvhFq(cZrDnQOsq<*{Z6{3m|e=8E{dPN#F7N#}$I^N74`2e|dJE?wQoj&7PlVdg}Mo~c@B+f zk}(xiX({h9v?t{2Y}ovbh2H3APTow$#-k&(9SyOnhD%qLmgVv}mu@wclkK*j? zavszD_VOZszj2k(@Q}GgjhAFEFQ5@rM$wYYB8-QnWxU^UCTKjN-L(WeGdfFIeqkyioiZaQP8h&hSpp3FfZ9J3|W)?}dOL^}ta#4-@^WTm=FdXj{)Fu7?N>>(U6&K`Z ztKEez%$MgDaF3AR&L zK0Q_HHF!VZ>$55Jp+#)9+3X>qVc`)SARTOi9Yi8J*zC&OL4;UgL2Jp}%tB(RIS zT{AQSEiCP?>OU-8>R&0hzp8I;c&=Z~P!?T&Wv2#L{-G==zjCMc7lx8h6lj0dexV32 zO6{-9FX1&qNpyIzhrmCS1a@(^Ylenf%P;ANN&Z8XQu%fIimCjZr2PAHN&fL_7M1ohWPE`Zr2Ru1ambWugDr|2e$4tNowc8O1K{y#FhPlK9hC@$(MP@j+RXf8O!QokcN}M28nU?eNMD zC4pVsY5y07hDTV+&*dXT`brs*zG5B*Bz;jroxa#57a5Vml9U9`di@RMjG`yYiqyEEK zDR(-3#Z-QzFB%%=&%fA1V26hI?c#3N3=KOmedIq>X-KG!U)Zi08hS!__zw{c3AP8Z zjQbHC935!zi-@2hoO)q+c$ilH9!`tv!K~fc78V*B@<;Yy|2iCp4Gjsg|4+mJQT)N_ z>2x{m5Ot0y_2r0+>KNUrb4(z0j&`{#NzT{yf+Vh?1KBt2;d9iybL zNy3MPTiGNtywx5Os!7`eS(8@X55%`FzmQHpqJzm?ej)iQ-(+cjwn$7;e$y`PZ?$t;CTlYD$34y( zUXzYLkTqGuTjS^U=hRGlAPb#Xeh$MQ>HlVarT?4Eph*kR+veu8ZxHWy=M|FOs{3dhxnRI-5|JVMx{DJmB779+^ zjGuE87(S4N0>fMV^Zp;${(;P-+fdq9%I}D@_J1bbe&SoRroi%>{-yn`^}~5JStv07 z+@?By=?$iTu77KIp}_D~JGXye`2(4$z4BYrkLVDXzLhy_VEkNS)4z~4e}Vp)PE6k# zJ}f*i{y=654sZ1z5*lm|WIe)J+s_)G?hV}ff&0I(=~wp;X>sk}ByHDqA*?AdeIZUy z+MoUE@Uq8i)?^JY-^IT^{+o9Brdd?yLe5{fOdMLLFJz`~W$jnTr}uxIKQ2FqH0^;b z6r4VXko36xf#CyLC@{R$za0OqcD9<#WVWGMem*XmB!!dlBGEw1gFtmWs} zG;>a@`H|y~nVz)2>0kDLlezta!&~E*7BOy7*3a}yXokePzRTmAF?A7~HcsE%d}Tgz|eUqWk^@;f3mi`A@8 z-TvAx`@hxB-%aLkf%%j6H^XxaoBla{D>DU$x7xY=1MPwAi2O6<4@{rur*-}~?!frD z#HO7o&>qN`S@g#zM;Lz` zVPXFIK(+j5J&blQ-oKSl-ST=Mvl3=TQWmavs$a3QFhg0yF7E$X5Btx0nCcJzSr1d| zH&hpN=A-r>TG~?UQU6&FQ{%^f*2B18{AWE(&hzN_qxO^kUF%`4K7C^Q#Kv~#Pi*(@ zPObdCyVDsR%-Wr8d@k`v_F(@yoIVfvpN9XV_=D5a=?0(w=<}&y4L*MgW~W0xae_Ol za3UqG$KxCKW;qwo}cHKV$)fF4-jCDF4{NcRm`<}Fp zKsL3;pLy2kF=vk*moPpvD?2B5@shm!rOOHmi;8_0mz0*3FJDoy5|4QF@6n}mr|6Cy zqoN{tbI8`gx>4MJKE9+O{rjBKt7nhy-MV(|(xr>j>5QSRvuvHzM)9@a{;qgDC+Zm- z>fw9ZnxV&!9Y0E+BhcSZ>3T{>`h-FG*|o~{?t#EIRXK(^omnR*p>#qWQ2K?882Z9@e?5*Hou)Agi)|UtDf;|tcpBt*s2nsS>{)uU+6S@Sgzg2o4@Ey+Qsnz&id)u-Sc zVbP++^puE|m#gRRw9BGJK6=C^w`6(lqN3uWT#mP(1ja>+ax=5?C1OfvMgHQlMQ8fc z5k4!3NBh}VRx)-B#YfT8J1Mg9q{^a2^q@~c{*od*VWh2GFn*N3O@X_CClAdwvU(`Vsd#HT#pBo9rFAb-P#*=!@|q?ANG|31PPY8yr0xt~)Mwn-G0 zyx9!W;iPdx_F?oHL7!3dIfFh11)4+=45II==yMT$GL|n^ zPc06nu)Jj~&kAC$%)zz{e!{1CvG!)mP!HqK+b`%@!ED!(^30MPWy|2oDq3RtTh4F2 zpxPk!a(-|UmJDe|sV08oN05&UItS0>C#UG4G#%8HT~J(FUXsgEWN;tJo1n2(zxErbNG?7vhtE5)l3;vy|#?mbLXb0 zT##Mb)!!=ux&7AQey{tpG)S&STSjqVQ9eECRZvix&%GkUtR&e(tc}X~3$`!(OMs6I zde|*<2|WV$2bCJ^uiZ-J^vrraq2|om5Adh!Kd7FqzR7>iN_tL>c8&a^{IYx+F)pFU z73s-fm+lwZPLBar(Cc6<`Lp<Lx3x5@ea{i)1xxlgFaKZrkIe=o~Z&r6!SJ)YmB z@(mc^qUcS|E?$(mA~PSur{8^2B9CG;X3nK?#g*)TcpTMZb4})9V@g3LJ-uyOUG!YF z973%2Bz}(&0wRc)9)!*;$V-u??t59^nRHVdN0ZddRI!mEsMUD zD0_kJOmdTtD!%QH!k5yUX^JSmJPIeF&!TVf5}5ujQ*js3-vZlc^>&>0;uSZ(R+v^$ zn#8XQ5|;q?X(hSxTqXRSlUp{ApZfHBh5H<lI z&Hv0l9p3f-WSd(HUAboMy7gCFc~#Yhjn!9gy5`!N>#o0H^Nly%yycc#Z@c}kcidTf z*WLHrd*A&JY<=*dhaY+LvB&G4c=D;IpLzCg_0K*3!iz7x{7S>NSGVtY?e(3FZ@l@| z+wZ*lUem7kKlt#Yk3ZS{>1Tic{EIKYYTonpH{br_yS**@zW?FJfBy8Z)}Md*b^n2b zhuRMR_WO~e^iE97$Le`qXP2(sy7%bWEB2J$r}pW4T0d9+0jCc^+}al`SUJFpT9ur|K#@nE9&2N!uaR%kAHFP*iIY+|34T3?Q8u1^smMIk?IkQ zb*-OHT_6o47jZyZ*+${-~sZ_F(^i zrmR*!PI?nw;6Hxo%G?eLB&H=Zkobr~`eX>EnR18*>zW z*v9iH+Q#v6SXQ3D;&}O;4D819FFa?$A9n9gA9g<*oCKZ%P9xK`0IoCh9G`AB+&meL9ENd{e(BJJKp#;`F7F|f8tsQ++0Amv%f&A&BpG| ze}&jwFmRu1FFy7cPyXU9{`h=fpXKM;M$)?w3sfJNQd}~XuIJJM-#$cX$@1iX`|x}6 z;r&k?er=uwa{YoL*!258(%_!ZUDgw|dtQ+HkMGHQB`Sm56K<0C%x(#CZ@5j|>w??| z-Xrd*^frn`wj^6B{o_q|ifxv1NwUqgO$~6LOM6-x+)V#7$^W_JI+tRat@cHU=Um(Q zwwdHU+m@oS({QCW<$kh$5%+Tl9mizj zexkRwNGYdgPgEe=&JZqx>i3~&-Tj8t_oO#PU9X7$G^mcZ67f2Fi+wJ%K2CT)G~-8! zN5`L6C3YQ;R&CeZ7?kfSu=W=Zjt+8fzDWApx6l^okI+`=erOx?2sCVwgm*$?p>fbL zP!BW}ng*Q7Rzho_wa|KK6SNuH2DN2Mz8p{|G#2WD#zEtu z2~ZEz3r&NjL-U}O&>E;Z-YSc0$Wn~65E_ypKTT`K%85=+?Jf1&B1LH zhUVN?a<~%ph1@87b{;9kkzc@m%4tDFX#wSy+{>4g>o;yuob-aTtXw`n;f>-iW}-B# z&YYf~lV;NUJn6&R%$cKdaz?FG@iOPoHrzFnHWzRHr%g zccrB~?85(s+g!>I`*ZnS*r)jR+Pt<2l*dB)TT1`*MsI$kWBB=0zp`ay%YI)AZHC6? zhV z`OYEIF>)RJ+4kZ%ctkCtQOFuz=je~>kJlkeRrtk}FCBwfYkw48Rz^xF7dkBGUZ?)Y z^--Z}LHaz$p!V+o}#Iifd@(zg@y)P8&%Hk;z$nk=Il z89}jey~wz^m@K?j!}}y3-2z)m=T!PwuC0Rn1+N{Z9?hnEdjJ)d;Fd zuCw+=G3nX5y>uP|%PI3XoL*8%?lgLpa*{8UuH?}9CcR$twn{C z8@o>}DleR)Uh>KdfCagwSf{d+ts8x4olLKP>0L~PBgbS~vYn>h@ob5Y+$ExvqQ%9C zi_;wv=L8Sho;qb_rq5qGnJ?pXQ>UaP z&n-S7n7{m{g?y1;3S#4Xb&`C(G=BZ-O3FAUG3N41dgWEwGjq%GigVcSN#|4chuF5V z2iiD~C-YZ-AaFj#w^WXYmCzb!Ep#dMs1bBllcr*}(HPDvqEqPnNw#Iwr$*RjsChbe z5&K;A`yb3+pTs|vLYz;W5yVwNTxa1V^4|zPm*yuX6YsXzrx3S-7tr~Mm$=QsDa5vm zCH*O6<#QA#So=>1vS(QA9KOn8pG#Z^*7<1y>+-c(nDg%}G0V?0F7X!T{Ch3TZ3(p~L z11HmL50^i-OwwoO@E!|u_&f`9_$n~hCzpRKIEAht*xm>}m(Jv86E_F3qg>KsJNMCe za2kc@@??OgQfw+c3$uNzg*ktX7M?}iYGE!<>~dYdbLd)v&bci-jo4@5sl;0>%z7Ur{f#|krkE>E0=xqi|t%=PWFF!zrw7Uue@xA6JI%@&?dY^yNSn@1Q2o@1Lw z*F@A`!Q7r)e{=o*&$V%RF0?SmpBKcON9*Q;ov$F+RtY|bT8r~r1Lpmg%U|o~1!_LA zF35jF5I2K)f93XR1$$}C;`};R>i)8Te9#&~5XXUa`ko+82d7bPxjlSfuCE!ymEZ+b zIh}0Jo?I- z?^l^$$UT8akS{(1TtfHfh)OIvybj0bk9_^+Q+eWRGMNQw-yg@vXHar)k;EwZG2`R2 ze965&x8w5C{0yCE@wqS`HG|8{F$LD{2#SNRDo<>e6a8_$o)})z;A<_eofGZ4wS(hh zcTP1+Q%Cbd&B0tV-=T>ZM$iTRRRY~MYT;^G`}TqkS6K>LZkIM7}|Wv!t2 zc&>-bT|zmQEzn=7x=OOnvn-)dC8~ybz9o~w>MKiWt3W&NX`ExeKH}>kR=x)1-ypNb zbMpKI`a3Z{+z(_#Xn)V=>ojwZ=lzYZg3J;XQTa>AEthg+-Q!Pm=l!ObT911d?@_X~ z=dXzRg1DEWwP`$7>G1XE68i8}J99Y!hIFYG;2y_Yus^=OE~J>a zB+@I{KhJ@dQwq{Q+6yPw*}P|Q`IujoX5+Q%~lPYg=Xwq}_Chg7YckHII_q zB0QqW7VM8l#R`8}PRy6Swk@F&^A;Rl*8`^_d22r%X?+>X+KY$nW*jRel6KPbQGWRv zTW`Vn;dWpjJaXxlcYU76nwwlAkx_$YLVim!ljCmZi?d`#2(C?DgBsLi-< z^M#~!f7D~69t$}J{?2g)9*^kvq$oeKZ_9Wh{o33wvel7?U1j6k@!5k;cL{~(`Lr@B zb#Po9g8Kun=xhJ_cs?TNh|Xo^`6E8gabMK_^>K#h@my*Q@B~U?;c(I2P;xyTFm)IB*m= z9<1-hNdQN~?g4iKd%>N-Y2X-eI@k%$0CxfBfxCiz;BMdwaCdMexCgij+!I^_js*v<$z^u> z1)l+K0}le*HcI;s20Oq*z)tW`a4dKj*aaRAjsuSX$Ad?K6ToA^9`HD@7p(V?H1K%X z)4>Kf1MCLpfjwX!I0;+<<~ar4D#3is%3BqfuOWG>0rNF1Z(G1Ag0@=lbnsR%Uz74y z2R>KORu7&9ZUCo&8^Js$z*`ge0zunu@B(l%SfB5-fLFu5W0JJ59Rols>>+wUs1|!D z*a_xWhViE7C&R%m*dxI4;0|C9*a1!hM}qbJ2OYr~ut$S^;7;I5aAzGJ90RTeJHd6} zE?_^=;fD^#U;56`5a0Yl9*atobTnSDA*MO&kYr!+Xb>LKR1NdBU6L=Q5 z8Jq@g1CA-e4zK&eCXJ7d#yH1n@*~8rT45fTw_c z;AP+{usvGF=Plqc@K$gKa6LE@+z5^W?*>PMTfn`+ZQzMu=XFxvWndSWZq!#>JU9&O z0e1kWfg`~g;3%*U91X4n_XgL1CxUCicAVhVfy2NJ;11v>a3r`H90hI#M}uwGqkX|n z@I-JN*p3s%1aKtS3yuP(gQLND;NIX0@I-J8*p3s*T5u$|4jct;0QUwrfhU4nz;>6k zR~tAI?6^V78wHL9PXxz-?E@uz0yq-v)#1VEIy^W}hmVu+6*@e)N{0t;(f)^v|E=0T zxL*4QH){X!;(xdH4{p)^!EM_A81e7eEai^`$AY84abSCb_)pMwuvgnBi9KE0!Fk&5 z5qpKUgR3+ri+zh`ukcpQslxS|(}WwrVXK69gL{Kpz&yLcTNYit@}}pv^t!XG;<9_G zvhyr3Z+u?^Z#+LGS_Bn;JpaKPUwQME2mf-{BmFKj;^S**-grKnH@+6O-IUl}nh&MeGS!%l&yj&^Ic=N{B_q_2u4{toL%^T0-^H%CFkK~JI-FPcN zx{Hxdo_FLekLEym7FN8bK4e`eHyo{9Z>*1QgyivA0x09$#(7+e1C$z4&nYWf>!=!u#qO4*vtZ|bHG*bd zw4M7Gmsh9H{cHr0_Rsx|`Fw=ue#iOI{<;5g{ps>^KO8}`J39VSs%5t8`rv*!f^v)9 zno{TZ=KAB~e#-gN@o|6U@?lt@+;Dp5tF>It68B@y|9s?+`!lDf>zD7<{XxMo_3E#9N{2#blmuwc2^VvNG>q+^=-GW+ZGn3IWa`&Lw&b)@g`=_pF8IMwI=OKL=Px$Tt*?7L2+g<06XIMG4bl7D) zne1;D86V8>GCr90A{C$64`e*xyIEu_RrNQA_DJ4K%>FI=wKk6Tht=Kd)4G{wLF zS<7k7hveTZr_PstW=+~F)xY0JzUKJzDfvpZxXCa+C zm?OHRpX~2Hl0H8_XRVi1%XrA?oBd7FpW+|yBz-f#e9trY-X!`P*#43a-LjI8nf`oA z{ipc*p`?@Mw@W%RsU~ET`fooS-eYwSm2~F%`;Vk!?oX0VvcLS+cmvy&*A2}hlf*lV z_9WRP-su+RdYI=gPpLYSF^}XDe!kx>;im-cr~DkGF0YI{x@SpvJ&MTv0$lHUT+sEW z$6N6~-5;N%$9M7Q{BwT!=}Fndzue=7F-Fw7F+{< z4_piW2wVq#AKUELBxy-w2~?1Md9+fl!Ea3$=?;2Q8{;9BtCz$S2DgAe2DgEmz>fQ+ zzVvZD7Tf@P9QXrpJjxddPJn$E*bDvwoDTj3oCkgrTmgOtTm{|+-U9v*ycK*exE}l{ zxDosncsKY4a0|E@+y;ID?07)x<6Uqpcn>%Z{C98y_)D-C{3$pc{5n{#i=Gb7gFP1< zkNtZnxB~V9uoLz{;40YjzzJxdDDW28Q^9EnKN7qZ_ENA1;X8usVc!gH1m6eV4So#V z0@la%Ht@5sJGM&wz6fqYe)KwPEbLXV>vhm^;5gXzx}z8QjfOn|c71)3j`&Bx?uES! zycOYN!RfF+4$cGX^MW+^?*w}V?6bfwq!$OSf_*7iudDY1Z-G4%oR0WAgSWztX*XL2 z>@l#{!+s;U5qusv5B{Ct-LUK9v={ju0ecJVaWu{eb<70 zNWTkMuPeL3vGBhE90#7G!z2E)zzMLg1Uq0q1MG!;3D^evKyW(ji@|x|YrqNcKMY&} zdm*?Aybjz5|NQO?-nPJgrJ#Quej<1)?CZf92p_Ng!~R!rBX|XPH@F@u4`&u?s$`k4fKBkWgzcY_}Qw}6*} z+rYPj>yX|lV8_D}|3Yvp>;u5Du;+l|z%PRnz}vxIa2+@uTo29zzXh%U?*!K){oddz z*e?X@dHip{TVQ_`TnBy$+z7rO+zh@2+<^2>1-HR|E77j15N^&#`caxXCFK<1VCO=bH6-fXu&eZ_(-Vd<{RfVC8ITvp^2E2Zran|E>PzT`KG%>6z^sYyv);ndB zbr3UuvQA^}m$GhYzNbdkpR9I{pZ8nYWL{gZV)ObimtU`z%Q`dfk9wSvbwIs(t=B>I zsyZ{*r@6lh^IzHIIrF8oo-UiLpYfA7nt8oznScM2btNx2APHd)8gsj+{ax97jw&h=@v%l>BCnG5~>PuBnV zuWYg|%uh3E=5;Q!|HwL#zAJ(6PvG>e{yBbgJdkxfGe5GjcLymjaLUjFboa{r+3}l_wtZ#l&#M(b)-Cy68!uN4- z>COHl_W|g;RoKq^v%cGf?+fAf;Ag&MllugG{{2PP5#_J7yjFK>d1YOHIpsn&S${Y4 zBkKh`p2!)6$+8D&*5QTo{P_{)r^aLxF7=NO!e##RI9cyE)8~~UUh_JiR&?}S0iq&l zJ#K#IZ>_5Xxh=@<@SBh86J@yA{TBHmzoQrv=-L{@W^}gB{}|Nc(zpKZwg#xM@Yy$B z95?R4t%k*()-Cx1zyC9gtS{aF3boqVtHzP9@Pi+i)l!39trGEBQ-)BpKu`zXlX zI$JxP&cTAy;9Qu%B_{$+2;R{ zyJ7v1O>Z@KytI(h^?msGGS-Y6pDSanUB3BJr8CE@VNG+~ww|@&;$v5_R@Pip&Dy&3 zg=<)A*F{~&+WgEj*R!V0TC|zfHmAc)tWDb=y_vQ3-r2XXx(*+>mDRWX=G$3oBNFal zt$Xd`I~CiXuVr=Zx#}*~hLH2`R=TABJ*+id{;9OmUVkrhbHdvDSe?(!xS!RtuKNS5 z4O>1}+VtB!TNOXF^g-692jd@NrF*Oxm*ne&8 z1f`WtSxRe`Rx5SxeM)Kkw9kdB!d_+n&5sOM+Vu2XrLA|aQd(JbuhKf#+e&Mm{Z%Qo z<8}_`x@NLyQ@+y5gEdMs?Da~UTfbBq|62GCRgTMtD{bmCN4R#SXk@KYTl(utbQtGSBR@z!{ zh0?m@2ZTGkp|s)I@0G@%7yUMeOZ#MmXv!?5o(FtNP$bN)HbK* zI~+b^!Z^{+=}K+yRVekXxvN?|U5<$Rm#4nR;hS!msI+$SLZy|TUZT`@(XC2rc0H%G^{h{o)~;<+ zn%3O0Nu|I1RHgA@!<0HVOi=0xpRTmIV!qPWZ}OD-rd24dti4L9^Ou{H#!tLoY3rrW zC{25MhtiC1KM;HLH%c3Z{i4)4#lDNv_sn*R&hMu*K7FK8+pI*TO^K;WYX>e=>I+?} zH0`qrrJe_`QkvnrNonn<`;^l7ptRwpSC!ToyOg$m`IS=Nil3BbIF2f?B ziFc0d=PJ%Rn)uF3pVe2-+LzcPe)7L|SJ{k5R}Q1RSLQ+0_bj9>X z6FbL`YjrR0Y-~Rman2`MdlI|9IJ4i|_6XyZe;hoo`Pc6gfB3ccX&o<#G=0x4!#iFa9x}{G&i&%Dre22=?-&<) zL58P?k#XuJo2z$48<#)0YH;qOy^IGJ-TB(gsxHRbrihFkU3wX9jx#5Xj2vZ5*fZ># z*ShyIZk<(n^nn)!8SB;V{@X^PpmQN zhN(Ypt&1=o{QH4Z+ZH&D9v_`Q=(n$X8Lxc%*egHI?_}KL&iiasbzfuLxCuwUs2^yA zb$u-J^0nQJJ7e~xTzd6zqwoBid$fK(#29<&nMLg7Yzg~2E{}KBV zmmXc+>AP&V(LMXTPdnc>(uh7g>y(<)hZt)vsz|6RKFfIg{)bbSE}UreS$@suO9!+j z{_DIbX7}E4KErl~QTzTc?^f@k@|8zLkBsYYy!pWV(ZBjS8E1I5cDsD_Fypih{kIpz zk2ccEtNHM0a*(%qipjP0~(i4Fuu9+%h|7YPBb1*zq0x5dq){}L^ZsB_xg#( zu7$7uQg@%rxaHu&0T~}B8sl1TyCUWZhq33anrBY0GK_;ao%U;&ZexvGWA482s(vGl z`<@%0QgY*P;XcUYoP`r^Y`MuXtz1<W6`Ww*)#((3?S$Rm<-hHgnQAV@=||=KETP8jtty+4_3jP-F4JFUqP< zi#ImUec{Jq7yUBp+p|ilpKeVY@^xm%e(T)E<1cpDadYps#E1U&R-b}6!?+=8KuX8# zIOD?McW>*_@p$62$Ub|g&OO_>qA;Q@{=13B_<~Pczq;iNV@=()Ph9c#Sfg?4X|}?1 z#u)uR=y^w#dz^9A(3PE>7mPLz+A|+pxoe{F^}+4)ocBZEdFZgDF;W7GnTD0es%tB zl+n$Z^L$a&c%%2#k2mGb`91OCA)8Lkzxr&-N8y0n&BqdNwz(rNPakc>-q|%|Z|qp? zM`MlY8IJY$cW@j1=WhP?l`)fyj`2yITc1cUvQPbZ{p2ZbV{F;@iz2fp7+;?9+`KC% zk1_85^hx{mZ;mzk+%R;)+JwPI{Pn#$S9O_W9GhLZ>GQ-hjb8f(Z20IW>Ze~UTYvrh zAx8D!k&9;jy_2!y?1-U1-}iIkm`TH{S|?94E;{Gn1GoJ&)c7`I`nuIK1{ot)PWgIr zry+)YRyT)haH_HJy^nj2te9?i7k{?$!n9(wZru=L^S6?ELHRElHg6c~WTPZ!Tm1r{6^St{rJi-56GV@YET`ya#{#YW7ct@lx)$w#a2u zF+R*RGQJ*n<=sVIqxJ6SpC8YiW|aNtef(&bQO3?)_g;DG%c(~0@~y`f)}3MWo!&d@ z)pwJOJ8$zuEqW)(@TCoEoHur=kuf0d?A@1-Gv0sB6aQkbfyOWYT6yWeuJIWAF8F+W z@y?mX1^c5PxFIanh`#^6cRyY?-FW_j*E;z=jyIxSYUx_=MzYc4^lxrBWq6`7dF`TZ z{dW#9E-U+Nrg7_FW7q>p`FFM*Nj%f>bI1cJ{f)nuuUR$Y(Q}Qcz1hd&^UpO#{q*U} z5qpx1>-+q?c39pBW7WNXull*e1mj@Iwh?0vdyJFK=eU~t(ZA#F)(%JPs~e8HyZ&Z> zsLx%;-LAGZ{o2+XcR%y@+DDw($K4lCo_g# zJLYcq(f(A2w~x7hus?rEgbAOw5^L@R`j=9VJVSi)71;^Z_y+2=h z-GpQA)6_=VY^VRn+#9cK`{v_+9Cg3hxAt@Un@8P$U-R7ZjK_|;H?BVI^k1$&>K-$^ ze(tj?j=G;LDX)Cw!lUlKA12ZNqwd}dkK8kS@KJYJL(#R*L?3m({z~$NMZX+zcf2ih z!@S)`+@u&{_cJ^V)u0KxZmBMRu*{1 zx_)=xJK)nZXGH$)j(hyB7q9%~H}^#~n^(8|{WtfizSnyDUi-~`^oOfP^?m#|_siK! zGyb*ZH~0KK@#lTF_BVH7@230hg}=F{Z_MkEbir@#-uEWa|KHrTeO|k2=3Z z`}Cn?S6iDqA~vJa9?|CZthOHw-+##6ch-XQ&iML}dw=+4NsF2exmVdoUjNj~huqtL zY<3KI^pLxH{Ikm*y6up=@!pCxsT&WuJH38u7stv&?k64`^X=zL4!H}bQZ2+>xtpFRbWx$n9Ix@xtbiL+)M~zx2%b<)C}# zxGBpH?K$YqY+N(w{#^&%y$ZJVEZBC?o!I-HsFWuTx@$`2?3#4fL3cw_)r51dBYWPO zo_T8yx_d9NkG=EagYLrv&RhCp=0W#8(s_%)F<%A9P3bOwU*oe$ahn#E>yL2M@US_GqeKxc7kjzOR4WzGU|S_XW-y zhE=_BzfhY& z-gE8!Ul=d#cQ1TpcJ0TH?{`nPFMo9P-TU23nx6b-{EhqFm0tUR@T&dpOS?aI&Yny5 zyBBB7AM74!U-#^XDZJV~=J@coB;|EXJ@4l+vNB^t6 zGl7q)I{W{bA%r0bVG;sKSY%k#Ac!NzHdXu1u!zBe4iGdd$^;TfG>~Zs8mz66qD`%~ z(V~qO?PQ;XY(>E0`Da!Adi&q{J>U4_r&X7{+wb{F**7{*4flJ3zB6qx ze}d=Svh0(m`aKC>z4C`2J=X8>&bGBg?dkW7eEi7WlNVPi!ym_bhv+D&ymC_j}Gg{gw{j=6=uVw&!npD8Jv+cXwG}`ZfKY-8bCzod;I- zd+wgOgui~zRsQ6kJo+#Fp4ax?UwT=3zvqm^;B?y={hrcKrrq-B)PB!ft1`>Bj_>!p z*tsF@qS$^gv;e(z&&y-uL zTcV%s^IQ?0d~Evf`aHAVTkO5~SACv0f7!p`rl0qD?)}!poL@Bbc^*s%r`jIu^X#m? zqip4lKF`auE56%)d!HvU<(7n$TlzfPpP!U^`we}bt(zBoKYCN2$2RYn@6Oyl&zRG< ztU2YXKF?Es`g_eUmiKwi|3ggtn#?}W%!|_RjQ8|;61vXiug}xm`QG<`FsILRj{EAr zWY6gHoR-;;>Ym7T?dbEAIc<-9GK%xar_RWy5l{804}JXJ2N6%j&bO}n;Bdr~;NP|? z`cTAk@8TbYTrWpF=RJ7tWs43(Jm)vu-$+n-=jnqU^VLT@lY$Z(RPBnJMUNN5oUc zf5wY)L}VX>!({!;`sp3^`x~pqzfbl$_5XV}GRIqOcnH*iyTG?W z0ayj1du{5ozt~hCcoX~yJPumGec)EG_HCQG3M>O2a5k6$#)DDdBW%cV;2oQK2D}WO z0#WahfA|IPJ8%Z)$-o6h0|g?4KL;KMR~@#gEU*kL1|D!Om<^_ZWH9MHn@R#>Ks5M_ zun)ky;C1i<81cSM9pl;u;C=8H5C$)T1K?l5aECRtV)6(TqCLunw23vI=yzJKcUxr9 z6C36s-|30$1!C8FSkvtwj%&YN4Ght->WkG3bj%|gxeN?V-@Gn1O>JvFBpvI~i=LSm zt6pe`o*74CcUrEUEDxqli6?1@y&g+E)1Fn&Ic0=O`vWNmPIAZIl$;u>g{Mauz*tcNup8N?|QyOwmUx*|t`O3U?5+ zlCJfz=BtBzrFC;%aFRo=crDknk%#ktv1Qt}rmxwz*fw<}C`_CX_R1{wEvlL*ZQW_P z9!5S{9wdU;G)rU6hooaYtoi7oP2GRAD+f5)Ay+aj*Zs)lmUA3hDUi%O|O^FY&*=4!bW06J2v?uaEvS;Q^^irnM{s+jH;3S9S(rdZyM?P8E#e~>2 zty%M-rDI9Mnh!s5+Ob=1Nynn9iCXzB*Ly6oD2NU7u%;_^t%o-xql2ZrX)+K#54 z7vUeZqg8KcJ4*iLS3r_pJ9!O0XIG`*WQXW=Sgwaf25G=&2_G6?Y@0PA#6W;#9AYcG7cbRs87r_*Z7NJC4EkCbU6`0)mP4-9umeq{d6w_L9j z8GMP`-8`6XTJA!(V1mpHv#?;N6IUN`fldQRAIBY)X85j&E`aQTvSt%o&V zrNk*Cooq|GLv_VwrR91j@|USAu|1rhNP5=8nx7DHoG-He8=^B*KMfu8$gs!~CN|8& z+CE~}dRWtSGZvL|-9JRfsxPsFmg^nJ!;NcV%d~AxU+kMl3c`r85oJdSJB%ED$*#S3 z-*Fbc$;QE|MN0h<{Dz0!{$G|-N5FS^Q1+rLl)4Ob0LPU|T><_IuH&K6GVlWEyGE%Q zYdBx4)Ikv7htC&P^4!4v^!Wy*lEM36d`PLgKs|T?*cw@0M%X*(V?P0W+RuIc5u5rd zCb^vd(@^b01LqtU>&#?Yyvle?cgr(AZQ02;92lI&?eah%+o8B^3y3J z{2ZkH5P30iuU@#NxHxZ9$!d_XI)82;mnzVXRN@NcNHJLQ;6t8Ul2=+XGgsTY@yP?}2W&>z zM(tvr4?PTEKApO4hqxtQV8?$fbiT>J>U7q>?&8%)y`*XkIe1=%&zSp8vY~Oj4Di+ zj44K#_DJ*qVHQ727rl_3`-te{dS8(+<>a21P06`>lG;91x72~=p2gb!hU`fi=h{OU z-HfsA69`*t{NH)+2=q7)7)Ja=5F6_QB{^#g^R#sSlRj+Gb`?F(?zY85shIR=6*Dh7 zV2fgZahsliCNr*RdMnUNaHxdzc$KhXOe8iux_eY0+CNR=?i-^a=K; zm_JI5NguDq^hXCo$B#~`lw-HuUCsy-A?=jE^P$3aH5NoUoSfJlh<2xp$n7!wS6%yq zD$ZUj_G9c)ZeMCrv`WfNR7vRxD(QeTAhs?bj%I5KLbe#d&~jm?4C_zR{CC*TBmK!S zYI1I}noPbXA4rKz2q$$XcIr0DP}gkSiSU5L#l}6tP8p7ukHW|Uc6$r8qio|HYJACP zH9i;48l}e1O9)RJX;&jDe>WT5)5ha>M3uU=o@?#2miVbLDwX)D#7`xDD)Cb1jSt&+ z;dxT-XqA)&r;k!e^PGVM{^`P4>Dd&!6_L`e2 zAG74+Yx1##4|_9RUaxz6Nb0MQsQz#AVNX;E$)ibPz1mz5{FNEF> zRMH;cqegV&w_+^ndR1&U{LyC{8?DCXk~i`%`Adk6Rv3BPOV=VZJS9H z|1v)8^(r-Ow3?WkswSqVsEM{j6(5cZ#2S6JT%MSxw5FpeE5LCZXfxx|4Ou z4ouvRPTB(qwPG(OI0<)-`r`kbr#|fDn6D)0)a>%HQX$bba?Rq_o zp&qCY>Te45H)Vxh54tZW66)n1OS$7zVzFNCp+0&DGyb>5mUmDY zj}fH#`N%(WZK*x=%rUE`9vny8B+@q%)VOq~8oQDjibRF&M*Bg0%ZbCeVdT+TUmQ&x zQ_m}61M(6F+(s3wWF5>}`qva#xEk!SoR5~eo{l2=V&~;mJb%u*`(^ZnwKOC#4sHBO zgp*{PVtmSCEKVP(k`ifmhfO)?Z?@5Vx3w15`sWxGQ_Nh&Kc;aMM+HXsnVa}0Gh=A8 zF)O0^wZ%v^KK++!ysbmYTq5bqA*`oCI*gA=j4v`44(f|{#|CWt!-#PujE^iBVzcaO zRJu)1w?xKbWUZf#p`X#$(&=lKewNDjF!8+L->lDWNmJ8zqCXb>cs05BM8CAnidVDp zN74t!;d_brUIM=7R8w~AzNhDR4Ec>Czp*N*nEYz>#5|SdBy6lo+U*RCPGO$eo#Zy_ z`!VY3Rd7G|7Q)Btit%%(?zLRM9UP%;gzfeyHDZE_w)<@Xv))FJ;k&_YoEh!e!@ba7 zz@^-O2-`-DP@@*e=uCVY`!>YaV{>ghb6N>)k{iXmHiEXXtMOsNPl-{dP#>qvn;1z6 zPv}nSObjIWoyPco!sk*?ai~*P4ARlc$#9{TKgco>T>Uq`!-dCz=%4XyFXwX1N505% zp2|N5aURfC8r{*Iy6>1iJ-t%Dzxz97lKVV4e;Azdfo>~xcC1RxAB$hPRD2{Z9MkRS zj1G+SM^WbeVfqZ|-B-n07Tinv!mUBpywyrI8~J$?9b-M^OBFxs|9oC#E#SIezt5~C zZMol+^Iovu$jfypf2cdsVj8*W*t7k%QN~*v4gESTUluVVe|Zp z;&-6?_Kmv!jBhdi0AY!*ooj0()<=vJwmjT@c#BPJI zHt#qo?^x!Yc$IRuG4HtIl#98{#a!mf8n0aGNy^o4%#Wv2e%ql3%#C+kut zhEvaA4z`^=>~*<^vQ3O(4oy-McTb2Ug%i7-o$-M&{y3j)TCAFuK0{68ACV05dLK5m zG*2JaW||a+LmzL3UkAwb)Va*_x%(Jro={V4j}4l?!|V^}<4X+V3u{Kk{iGF)IokN@ zRAUY>zDgR2ti?-YUW!+VyJLMeXS8y%#&n|ZToD&Y;GcLonX5%M+vl6RmHG~N*60hi zI6L#)NT0qI)z^Ba?mG{$ce95v#?VcW^cWWtck6SYsaKB9*$*@3e5ec#QjJu+oUH_gnhckbaw*N<7wSsjSmdsaI@-)f>!32yK-*~Z4|7iza}Vo?$tx`L&m_B=bRcQiHn9IzsWHH;H=A=Lemy}k zYU1Urr?h$;+-?)tD{uib&Tu*%Pf>5+IZY8rPS{yWo@d>^(7-zOs+nc6QtFle(z+| zFMe;dlX34vyR#-V+unM=tc|Cvks+Caa5jALw!Wo(R5pjNx1Mg^RYP95C;u>?soo};#1N+JEY3K~sF3Y)oB{18? zCT+Vr#+Q1gjD^dF9k+aB%a$@yrEE(IjPob@5|~f*@i>n0n0o=rlCnY{k5k>TwC^`* z-}TBFVJzs5>9p<{xa1x}^LKnbi#6I1e@~qitCG`~v4&qTY<%g|wo&~4Y5}aRHMxhl zo3*C(-rSgX^y~Wlp1w|JjZR(@R~YN`Gvq#OGUeueVVJy@QO)|ea$=k{>-xxhO3i*> zsgDfb7_P1#X2ZJ^J+rROdq~s9a^hbJ#trCW}RmQrtLAg^?5a(v4r(JewlQ)tmS21AuOFRIX`}H@%elB;mY^@Nj9|`9M8Mv zv!k^=2(w)doXSSiX*QK^_`%RI>uDAauY+Z#pGdo~=9$czXEJM^$*fVthqX1k+>ccc z?;~4h+0<{qdee^R;$Oq%yK1&geFBc_Cea6eJ9H&Q+(`~Ki8aQg70HqD;c?vwon!rG zxvI|P-UgHz>7||%t4>Xy&YEoE;Pp9kRo3fx-L-c0uejC^=F(0asb{iJkyT-zl>S5e zB-`zFV`ZW3J$jQ^C!Nh$lXb6sYWfcQRND{j+Kkl6jO5qn6F)loxG;Dt={EaC>Qo2yJ63DovBm5t2ONIs<7u>$9A{_g?KI3>5SIPb)am%l z8=v=?ywz*4c?_V!u;cn=@^y)S2uf;U}??(cw}0%3Zs6mAIX9{md~J zPTj}e74egaKaTig7sed0?v>>0dgo3>XA(Ne=!`ojes@g75svPT>NNKNveDD`7!ue= zVbA42Y(U$KvBq0De7uC@7;Ud6nRv;?<01*+vE5@jPwc~dw85rY^MTQ>V+(BRbYPwj z*Y_@2Z&Mq9Ic8YbGjgv@TMVidsS~DT^WM-scss@O=T}pTF3q&fjcPr61~h+SYR|Pu%0lcM|3vxO0n5-3#_;`uGU* zurg44($7$O?k_0>TR1iJ&?IWZeIi7Z4lsTSq|5B{`fy}4hF0-l0+ZZEE zyIT6O_?xb$^&#?VtfRW)wcN7i*48zw6&X*)GtZ7+k-(Z)=A;w*V+o(vIe!0g{*P^H z8#q39OpQ}hOPs95$Ffd~S5r^yb@^=Ze6=ty#%)W9W?eUmbsan}$v@oM_|!(eF9&wM z_mv~{4EBRd_?{?hGVvzyeNl?y&R-j=+vWPqQ7SR_4Ax(>=+~zyYDT-}B6{l7k?ajl zQ)6tWXnrYeL{z2k5yxtKiO1W`#Xhsu|Bd^3x9Fcv9c7(CJ+cy$-~U!dC;!0C!U-;i!nP5A3dG*=S*!6S<;p3`r2T~zNE2Vt?hj-ApIFKHuD`- z@nHWp^KRoGV<)nXNW44NC*PHgwS8YXBGKWfZhNPe4jW6;W;xWXl3Qt?+f-84_mm^O zT(v)GQwx62GX)>({m^=Diyf(A*|&?OPfMMqvSyU~5V7Z?PV})OM&FN>dFfDsN~Zmj zY5(NiPM_X)Q?ga813SnEkO~qr^Jj`bk%-^e|a3L%oLk`zu zJ)oWMrH3A}uh~ub0Fdvkhdboi139ee1cs#JO&CVbYOuoUG2wcy4~%F!Yd+Ou~oDoBY;P4r{&^ouLH{`Y`QRoWy?UB=+Su zUvgOO_uhNLwEPysJO=33`YxOqGMMEz8gg_P++}ds-~odtjL`Mw8obEhD-FKZ;F}CC zH+ZMPj~M*4!EYHHrR9(Pe}m^3oN4e{gG&wmp}`@8A2axX!G{dq-WaiT;j)~-%97%OO&hQ| zYQ#l(CHh&`)<7QL_rGl;WT9`#ru9Y2F>*yo;li9i$(G{0g+&ylv_v^2Y-v%^bz1_9 zw`|f1L?Mg$7ARS+TvkwAvL&Z*)utN?Hsvby@yJ!1@^d!j7Utz%Sh_ARAmv|NP$-q9 z9v!(dujHhcy>`im{)O7hGg_2`Htn~jsA;>CG6l2>1G z-e!ITsmh|3Z^dPx$UsSv?XVW@Lu|;dC`JcDGBv)N%3C+qc&dbRqP^D^hv~_by z-o~tgjd}AoQ-C~?)P0urTDi1fb4eyqR2w;3l(%-vh7EbeW=@n|&pA|1K&tj~RV!&N zE6Uwcn3t(l5Ox2J3s+on;nH*F&CM+=0kAYDm33GOKX&{KCSbbv&FZ zGG;H!Dcq8$-jg$o>SyoB+2Z27JoTJSXlcRP;vAge70HJ*%lzD28iQZXeK2BaQBJOL z{lZd8YuD=}S1-O&YoafwqvT0xRq#aZ$oVBX8^t$owOv?RpqUkuH79g*6PndeHUBNz zNOP0gro8#;vmqgut8a~b_oNFn7v&6+N_a4nQg&Jp>-P1hF`7j4=|m)9#@>g9mukHcNMLUM1pa9K`qf&5bQ za&@;{Sy^)2Bi|J3#^53z!?!}q=P}yZ7k|vFe(lWrW`D8X$u$0Owd=t8gOciJpKYns(-&Ftps!{f zW>oD|!mWqsTF-}*ZLZ-$|KnkH><-P(f7~kN#_oxg{J+nl`%=AK=Vj?E_Ts?t+BD1t z6Gv$6zuNtu!#5j8tzp-1*!{P%GUCrAp91qpH_Bt44{d+5+-AF&Ec#a2jDIrDNYd-$ zf9mzm<;$qAq2cYz_4aqK)Y-LK=b?IEblz>)_a^K0vXBV>mim--lEX}=OvS`}*)hh9 z^S^;@UvSum93zawEZe7+I+8Ho$}IEJzl(i~{)6%PAKd>j3;(WcACKfyi~d{F502OU zJ#4URf_@$}_;^PD(*^y_O2d8XNx4pX{HJH-zr|qA+I6{k>o?>VTzg&N#!W?mZ?cHp za{UdZTW{2}Gk?LtMHeo#U^&qdo4}VGh`G)=@=s#P1sCuIMb9Ha^RVTOqohmKHa&9D+zjVz@F16;RYhRl8 zdHv^lUJZZ5?-#zK=S=21IZVaUuMb|I%=OH_EYIA|@@_84^?Ehc;q=z#ek`YYOu=Z79h%qnuPqg#A6|dWlA_He-2ZRXvwS?}JWJH!()qIW=9wueto3Gofj!Sm zT7eqIu6NNY&&+jf{;nx0&M7G2T#sw9ptulFR~MU9E6d(;Ru+6EX>bmv^umt*DcR`FQ2N^YIKAPK?$<(tzbKH zC;SDH$d$hc6A7TY8L*1ydPf3 zcic&$1D65GLoNJ!L+*mFXOA$0M_NnayTDT7$|K2-NI3c(@a1!;E9}U_z&{2O9)u49 zsej>dXHpj8Cc!s=F62_!#wJlaaiid~faJjq-w!12PWbmmco#hCEZt5D{2n+;-Xic* zZpuad?}y9Jrf#Vd;XIZyCD;$ZdFP;mem?vTP~_n-d~Ld(Rv~;Fko?~PHv_Hy;U|so zF8G{t`7H%D)8WT~iSN4cQGJ20J7_aNuj~ zACS)y*n6IyH{p+g!sao!?|hy&LC1LkuM-13$OqxHuN!p;mjS6m;h+b*=m@_8B%i__ zuVEj43gnZA{qQIA_4+&pcP>zBGI52=7E&+B!kK*IBH_Y60Fu@n@b7`x?}A5MsLS#& z`&WR}Z3g@hkowsJk6WzAO@e(u;%37~K^g5RTyzobh#Y`l1d`S(@CQI_4!|2S_3(W7 zejs*s!p{TI>4D>y=&}>;0b)mZ)Hf&>_8ss=OXH^{lKLbRk8y>w%m*e2YhMWmM2gLqCxbQOSleoeaK*EK8VaR*ozZvoX zJoa+krabTdBOrY(2)_@4*pc`1+fFG6J7~71IefGlGT)f@TJ0F zKeDj2a6BrMcvlaN%kocA8;lp6=Vi3xJkq zc-DIS8+{*q+Xj3axg2&BkXK~k*lTGU0-!g76f01(39|;07Q*9D;ud zB(1&hGltv^_X5!umfxa_EPNZ-D|vu@Mffwa@FpO3Zi4SMYrdn)e)!Vw@}4BZeen0n@f*>B-@Y9` zK|T!k--%7+qwu&N@iTC2Cc!H!^f5LIzU6Ml0(7>+v+kkqBd5bRgE;idVEes#S>*R+ zGk>DXnQ;1j==7ow7yp#JAs^exoc@5Wvjg4-q)vpF{fu#+dho%ks~PLj7w!krcaFj@ z*DyvC{tBF1tB1Sl7!yDxaU*cBo-!hL!|wvGgu{J?tQuGY013YU-Ug(Nw!^$XpYauwA;J2w!Z-KKOb=E`xt>$X)PR z&HB9KhVKV5&+deKf!GvY)k>d#m$e`K30Q=D41TDM@d0@cd;rKA`yf22-N*y%{kcAt zX2ESh%GC~k2r`hJyLpcRD8bGh@YxSh*U0JcevpMMoWF; zR3aaSOCQnOOZehPbvs$`uYlxpFZ>yhJg5$Q@)wlxFg^*d0pcfqc;7E6FX6(gf2G?I ze)89h^@Ml9e+FW+7ryf`rEVg;0{$Hk`(5z5-(ZXIT=<$!y>9*R#gFUtvlKoAq`bm2 zev5y<$D9aP1F7d)*!u+ig>d2Jzhk^Z&VoMx5$q4Z=RQe)Bs>G2`g=Vs7rd$qKPNmJ zzWyn_jHPflxQXx{342;^qYL28hFk&f0$N$%k^f5HLEiy4{DC&*=JY z_<11p8HR6rR+r1+M}gSvfZs9X!?62#>H<4n_!*$}FZi?Wg}vc;QD3xd-0zGIfs4QuwY{7=Mu4U**?3z=y0}BQ98t z?1k?G+mV~$XRqPD&m_Mx8-KVpP;!hZu|a{x|%TTfTG5M=+AH4;4M z9qb?rkA0UsBRk=*i%hy+xE374P7j=PSWnjlUv0>K_*O%%gb%z&ejqa z@?QA+6Ktvn{X5`h&@DFMs$}XDxfZ@6g=Zd_cUHqs0Byd8{~wS%hvDg|HqFmx!h678 z;tG$QsLM_`3y8k(^@dyqe*j9!4==b<7l1P4LikD0CE=5KHg^j7L*4^BPtog8_(~u) zSHn}L+Eh6@E_ffKb`JGPxD&1drO37LSI;Ib z3T=>0nX-D)U@YJu_R4uX#zWqG>51l*U4?#2X0G!E7 zD`m|fT=R9C+Cg|Ne1^xS0?6CpQ@rFKoiupre9|M_1&4stkMQONdRa=~qDA!C4;Z81 zpIu~AbC84ZW0^K}h`62bRGyVhBHRW43(w51M)tyg1=79|`1VWnba%jWeY%_h-vT7v z?eI62+q8CH3V$DzW9JU|LnE9YnX79+1>t`9=9M{4k_SJ0k0DpWPZ{!l*tS~NiGt&0{i^b z1G4aIIn)Dk7*5EeEs&GoCa@j39X@Bh?pNvXP2d>e!c9QN`TcNO0X{&u8*TzFo*!+7 zQ?9jX`y|2@*V(lBx(mK_BW;9EIXrulp65C6W{^pE2|O!6UXl00_kYu-3Xy|w7Z5+U zKFcc4xJH+dXLN+8gIeS=IDU(+Z+(tco^egNo;pWIcs@9YESzP?`EXLHjTt_c{gJVoeSWr%Sa2E{|cz)Zo_Yp-Ea$#acj|dw1n;ciS;CLFM}Tj+ zi|1F7JK?_q@udiS&)xV6_fVB^FL0wHT=8S(C*&}E{|>z`?}QWX(epD0{>r`hKROxk z%Ae9k$XReFkoiKm;X%e3?1$i&fRz0ecw)7#KN+4`Lwdv&?gTQY2p_H0^;MlsT?QoF z4|f2uv#8#te%YYs{}4PWq^G+GJ`AMZgs*J0sUY@O!;b@ryALjCqON!*vk*RimmYor ze9(}EpKN8$AZ{1DyNxzL-UDxLr=N2FRRX^XQm_+-xBi@ZCj2J&gNJlK8Gyrk@K4c! zTOQWaYKIp;qRW}^4?6GCGxd-KzX)XQ@d~{9G5Qqx ze)t1Wi|qOh^Csv(E`|RFqz(t*b2{~O)8W*|^)YZV`~(o2``{VB)$4F3oC`X!BmC$S z_$6{D{LVg`R-b!*$NcpqK18_n`Br)EHSKBIi04OzGr=5WAN&qjiX4GM&yZK-c6iaV zlm}Tj8)*F=PmcLFu zSsTdvH=Z-(gYc(dH9GQK{5OF3y#G!9CmK-n$1?af;6M(-^+5JLy5TTzBMUEkM-LCc zWgtMfu;YC_+zo$d$j-mwYrw~R+6{j-Lb_5X@E<@2V}iVtcXl6rggndJf-f;-dExIa zLzWk^z6V0D+m*cVQ(j;zvhaO|EbqmXcU?-ju)JGw2lXi|?_`W3pThF~M3IH%9elaS z!txHnIrzD-ynj&a2+RBaL`PWO^(W!N^8P~!7nXM)O1QARhfri;c?V$ydr-piE)kK1 z8h2`B* zA!K2Bw~^=z%R7oh7MAzah%7Ac6%bii-W4OVu)Om{WMO%yiR3|8-g_b8!tyQzk%i@b z3nB~4I|W1*o@B`KJh#`7g?9i4-&u6P@gM8+krTcINT2e-KLm%-`RDP^8u(`o{7@ds>V^{tVyYH)uh$9YcgtlHQ6=(n*5qTO=(S8O=V56 zCR7uy>8**>IBQdCUA1Yo?%Isn{MtZmX>D0;d2K~)ur^fNUfWUIS=&|HUE5O|uI;T& zsdLq()m7F7>q2$ybscq`b)}*5P-Q3->Iij(dP2RSfsmsyr7^8BqcO8FyD`79w6VOg zvN6=y(b(14)7aZM(CBDNX-aF#Xv%ELZpv>eZ7Of7Yzj4XG<7xgH1#$OG&y#q>`L2} zu`6>|_OAS0rMt>^RqhJy>e$t_t7lj5u7O>S=9K2N=8Wdd=IrMD=F;Z!=E~+!b4PPm zb5C<`^FXtsC8Z^;C8H&?CA)=obF#jM^z!*?vupj7Qp#63YzZT^1GTEoQRmc3>aNSE z^VVh7`RcOk{B`+tfx6PVvbyrRia~YIRo7kDQx~r5t&7wR)Tw$$y|X^0-c_Gg@2=0N z_tt0D`|7jn{q_0vf%=Mu%7$P=sDW3wt90@eXen(eYbkH(ZH=@Jw5m2&o4d{1=4+3Th(0##*I6;;8i_NvaR?y7KAq)Jsgt6kOZYHzi#+Fu>0E~~Dn4pz70 zKf3oQJjaFCc<~xP9#d9RfxooZbk=m^Gm#oq>%?Q+wcc7EwHd%)DyYkLJf#~iiBNw| zYR^s0`KYx3HCBPgwBs$^)KY{Ra#A}H+Df%3ANR@Pzm1)ENH;zb#!DjjiE45*Iq?-2 z-r~kzT)W)6ym*BVzwqN30nIlm@Qxt<(T<078XlsW9nDU>#D$-@@f0t<;=^0~_)7qf zDZ^(f@R}fg(~jqK;yc}VPZ{fqkeruq$w6(0Y zytSgWvNhNmYHe@rXzgt6YVB_AX{BBLvWH6ZR)=T}vp@IHqkD(#)83j)TF6H~^3#*r zn>w4io5D?zCbi4CORp^-H5J%ZwyT0VYNvj>cZGLFb}4GdMa_7r6+bmnMr{PCiB4)E zObsYX@1o>hO6}K5TtR8uDQP#Qj8H-+rE^md z{I=4z^0vyhP+Lb^S6fe8Z`(kdD&t-me{}>?f@#5wU}i8om>(<+mIo_?p~hAl z5TkV$BXuuhn4>O*kvfC1E1PkvlrgK4F}tI#i;=3AQOdyxmB#3l$;gynUs_*YUs)fj z@2Kyp@2T&tAE8WHe+pWH;nDls1$zZiN~;8oC;K8hRTB8XTdNP+BM>lo`qn z<%dcK%>q2OtqQ55FFO*r86$m+kAeEK`ilBseS3XpeRqAhK2on5oDHr9cZ0XV*Whmm zG?X<|FnYE(bT)K1gc~9aD&!2gLhg_^QY?QjN|=SEIYp z+vscbHwGHZ8Y>!ujqQvz-HbC4#uz8#i@V9&|VkA9%P0mkpB^Mla`kr<{4G(V4g`~rb%P2$zZn0#Mk|J zdjNkg!{aOP`F7@<6#P6JAFsr_^)-pi)-L?djR#gRLiaX18HfG!<_<<62V;+)F{g{s jCWV=@y^Ta&BeZ-edSrmU*u^}U!VFkSuahkOUp@XmnCE9O literal 0 HcmV?d00001 diff --git a/tests/example1.exe.cfg b/tests/example1.exe.cfg new file mode 100644 index 0000000..f1adf36 --- /dev/null +++ b/tests/example1.exe.cfg @@ -0,0 +1,151183 @@ +{ + "binary": "tests\\example1.exe", + "arch": "x86-64", + "format": "PE", + "entry_point": "0x1400054bc", + "imports": [ + { + "address": "0x140020000", + "name": "EncodePointer", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020008", + "name": "DecodePointer", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020010", + "name": "EnterCriticalSection", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020018", + "name": "LeaveCriticalSection", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020020", + "name": "InitializeCriticalSectionEx", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020028", + "name": "DeleteCriticalSection", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020030", + "name": "MultiByteToWideChar", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020038", + "name": "WideCharToMultiByte", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020040", + "name": "LCMapStringEx", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020048", + "name": "GetStringTypeW", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020050", + "name": "GetCPInfo", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020058", + "name": "RtlCaptureContext", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020060", + "name": "RtlLookupFunctionEntry", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020068", + "name": "RtlVirtualUnwind", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020070", + "name": "UnhandledExceptionFilter", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020078", + "name": "SetUnhandledExceptionFilter", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020080", + "name": "GetCurrentProcess", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020088", + "name": "TerminateProcess", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020090", + "name": "IsProcessorFeaturePresent", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020098", + "name": "QueryPerformanceCounter", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400200a0", + "name": "GetCurrentProcessId", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400200a8", + "name": "GetCurrentThreadId", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400200b0", + "name": "GetSystemTimeAsFileTime", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400200b8", + "name": "InitializeSListHead", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400200c0", + "name": "IsDebuggerPresent", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400200c8", + "name": "GetStartupInfoW", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400200d0", + "name": "GetModuleHandleW", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400200d8", + "name": "WriteConsoleW", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400200e0", + "name": "RtlPcToFileHeader", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400200e8", + "name": "RaiseException", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400200f0", + "name": "RtlUnwindEx", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400200f8", + "name": "GetLastError", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020100", + "name": "SetLastError", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020108", + "name": "InitializeCriticalSectionAndSpinCount", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020110", + "name": "TlsAlloc", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020118", + "name": "TlsGetValue", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020120", + "name": "TlsSetValue", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020128", + "name": "TlsFree", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020130", + "name": "FreeLibrary", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020138", + "name": "GetProcAddress", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020140", + "name": "LoadLibraryExW", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020148", + "name": "GetStdHandle", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020150", + "name": "WriteFile", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020158", + "name": "GetModuleFileNameW", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020160", + "name": "ExitProcess", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020168", + "name": "GetModuleHandleExW", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020170", + "name": "GetCommandLineA", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020178", + "name": "GetCommandLineW", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020180", + "name": "HeapAlloc", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020188", + "name": "HeapFree", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020190", + "name": "FlsAlloc", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020198", + "name": "FlsGetValue", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400201a0", + "name": "FlsSetValue", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400201a8", + "name": "FlsFree", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400201b0", + "name": "VirtualProtect", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400201b8", + "name": "CompareStringW", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400201c0", + "name": "LCMapStringW", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400201c8", + "name": "GetLocaleInfoW", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400201d0", + "name": "IsValidLocale", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400201d8", + "name": "GetUserDefaultLCID", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400201e0", + "name": "EnumSystemLocalesW", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400201e8", + "name": "GetFileType", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400201f0", + "name": "CloseHandle", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400201f8", + "name": "FlushFileBuffers", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020200", + "name": "GetConsoleOutputCP", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020208", + "name": "GetConsoleMode", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020210", + "name": "ReadFile", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020218", + "name": "GetFileSizeEx", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020220", + "name": "SetFilePointerEx", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020228", + "name": "ReadConsoleW", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020230", + "name": "HeapReAlloc", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020238", + "name": "FindClose", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020240", + "name": "FindFirstFileExW", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020248", + "name": "FindNextFileW", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020250", + "name": "IsValidCodePage", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020258", + "name": "GetACP", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020260", + "name": "GetOEMCP", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020268", + "name": "GetEnvironmentStringsW", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020270", + "name": "FreeEnvironmentStringsW", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020278", + "name": "SetEnvironmentVariableW", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020280", + "name": "SetStdHandle", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020288", + "name": "GetProcessHeap", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020290", + "name": "HeapSize", + "library": "KERNEL32.dll" + }, + { + "address": "0x140020298", + "name": "CreateFileW", + "library": "KERNEL32.dll" + }, + { + "address": "0x1400202a0", + "name": "RtlUnwind", + "library": "KERNEL32.dll" + } + ], + "indirect_targets": [ + { + "instruction": "0x1400054c0", + "resolved_target": "0x140005d30", + "name": "", + "library": "" + }, + { + "instruction": "0x140005354", + "resolved_target": "0x14000550c", + "name": "", + "library": "" + }, + { + "instruction": "0x14000549c", + "resolved_target": "0x140005e44", + "name": "", + "library": "" + }, + { + "instruction": "0x1400054a7", + "resolved_target": "0x140005e44", + "name": "", + "library": "" + }, + { + "instruction": "0x1400054ae", + "resolved_target": "0x14000ec14", + "name": "", + "library": "" + }, + { + "instruction": "0x1400054b6", + "resolved_target": "0x14000ebcc", + "name": "", + "library": "" + }, + { + "instruction": "0x1400054c0", + "resolved_target": "0x140005d30", + "name": "", + "library": "" + }, + { + "instruction": "0x140005369", + "resolved_target": "0x1400054d0", + "name": "", + "library": "" + }, + { + "instruction": "0x1400054a7", + "resolved_target": "0x140005e44", + "name": "", + "library": "" + }, + { + "instruction": "0x1400054ae", + "resolved_target": "0x14000ec14", + "name": "", + "library": "" + }, + { + "instruction": "0x1400054b6", + "resolved_target": "0x14000ebcc", + "name": "", + "library": "" + }, + { + "instruction": "0x1400054c0", + "resolved_target": "0x140005d30", + "name": "", + "library": "" + }, + { + "instruction": "0x14000539b", + "resolved_target": "0x14000e8f8", + "name": "", + "library": "" + }, + { + "instruction": "0x1400053bc", + "resolved_target": "0x14000e8c0", + "name": "", + "library": "" + }, + { + "instruction": "0x1400053d7", + "resolved_target": "0x14000566c", + "name": "", + "library": "" + }, + { + "instruction": "0x1400053dc", + "resolved_target": "0x140005e28", + "name": "", + "library": "" + }, + { + "instruction": "0x140005408", + "resolved_target": "0x140005e30", + "name": "", + "library": "" + }, + { + "instruction": "0x1400053ed", + "resolved_target": "0x1400055d4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000542a", + "resolved_target": "0x14000e868", + "name": "", + "library": "" + }, + { + "instruction": "0x140005432", + "resolved_target": "0x14000ec90", + "name": "", + "library": "" + }, + { + "instruction": "0x14000543a", + "resolved_target": "0x14000ec88", + "name": "", + "library": "" + }, + { + "instruction": "0x140005447", + "resolved_target": "0x140002240", + "name": "", + "library": "" + }, + { + "instruction": "0x14000544e", + "resolved_target": "0x140005f98", + "name": "", + "library": "" + }, + { + "instruction": "0x140005419", + "resolved_target": "0x1400055d4", + "name": "", + "library": "" + }, + { + "instruction": "0x140005402", + "resolved_target": "0x14001e360", + "name": "", + "library": "" + }, + { + "instruction": "0x140005408", + "resolved_target": "0x140005e30", + "name": "", + "library": "" + }, + { + "instruction": "0x1400054ae", + "resolved_target": "0x14000ec14", + "name": "", + "library": "" + }, + { + "instruction": "0x1400054b6", + "resolved_target": "0x14000ebcc", + "name": "", + "library": "" + }, + { + "instruction": "0x1400054c0", + "resolved_target": "0x140005d30", + "name": "", + "library": "" + }, + { + "instruction": "0x14000545c", + "resolved_target": "0x14000ebbc", + "name": "", + "library": "" + }, + { + "instruction": "0x140005465", + "resolved_target": "0x140005690", + "name": "", + "library": "" + }, + { + "instruction": "0x140005425", + "resolved_target": "0x14000ebd8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000542a", + "resolved_target": "0x14000e868", + "name": "", + "library": "" + }, + { + "instruction": "0x140005432", + "resolved_target": "0x14000ec90", + "name": "", + "library": "" + }, + { + "instruction": "0x14000543a", + "resolved_target": "0x14000ec88", + "name": "", + "library": "" + }, + { + "instruction": "0x140005447", + "resolved_target": "0x140002240", + "name": "", + "library": "" + }, + { + "instruction": "0x14000544e", + "resolved_target": "0x140005f98", + "name": "", + "library": "" + }, + { + "instruction": "0x140002252", + "resolved_target": "0x140001150", + "name": "", + "library": "" + }, + { + "instruction": "0x1400054d4", + "resolved_target": "0x1400060d8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000551b", + "resolved_target": "0x1400057f0", + "name": "", + "library": "" + }, + { + "instruction": "0x140005520", + "resolved_target": "0x140007318", + "name": "", + "library": "" + }, + { + "instruction": "0x140005674", + "resolved_target": "0x1400060d8", + "name": "", + "library": "" + }, + { + "instruction": "0x1400056a5", + "resolved_target": "0x140010b38", + "name": "", + "library": "" + }, + { + "instruction": "0x1400056ac", + "resolved_target": "0x140007340", + "name": "", + "library": "" + }, + { + "instruction": "0x1400056a5", + "resolved_target": "0x140010b38", + "name": "", + "library": "" + }, + { + "instruction": "0x1400056ac", + "resolved_target": "0x140007340", + "name": "", + "library": "" + }, + { + "instruction": "0x140005d5f", + "resolved_target": "0x3048e", + "name": "GetSystemTimeAsFileTime", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140005d6d", + "resolved_target": "0x30478", + "name": "GetCurrentThreadId", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140005d79", + "resolved_target": "0x30462", + "name": "GetCurrentProcessId", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140005d89", + "resolved_target": "0x30448", + "name": "QueryPerformanceCounter", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140005e60", + "resolved_target": "0x3042c", + "name": "IsProcessorFeaturePresent", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140005e73", + "resolved_target": "0x140005e38", + "name": "", + "library": "" + }, + { + "instruction": "0x140005e84", + "resolved_target": "0x14001ea80", + "name": "", + "library": "" + }, + { + "instruction": "0x140005e8d", + "resolved_target": "0x30388", + "name": "RtlCaptureContext", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140005ea7", + "resolved_target": "0x3039c", + "name": "RtlLookupFunctionEntry", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140005e73", + "resolved_target": "0x140005e38", + "name": "", + "library": "" + }, + { + "instruction": "0x140005e84", + "resolved_target": "0x14001ea80", + "name": "", + "library": "" + }, + { + "instruction": "0x140005e8d", + "resolved_target": "0x30388", + "name": "RtlCaptureContext", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140005ea7", + "resolved_target": "0x3039c", + "name": "RtlLookupFunctionEntry", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140005f1e", + "resolved_target": "0x14001ea80", + "name": "", + "library": "" + }, + { + "instruction": "0x140005f3f", + "resolved_target": "0x304be", + "name": "IsDebuggerPresent", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140005f5c", + "resolved_target": "0x303e6", + "name": "SetUnhandledExceptionFilter", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140005f67", + "resolved_target": "0x303ca", + "name": "UnhandledExceptionFilter", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140005eeb", + "resolved_target": "0x303b6", + "name": "RtlVirtualUnwind", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140005f1e", + "resolved_target": "0x14001ea80", + "name": "", + "library": "" + }, + { + "instruction": "0x140005f3f", + "resolved_target": "0x304be", + "name": "IsDebuggerPresent", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140005f5c", + "resolved_target": "0x303e6", + "name": "SetUnhandledExceptionFilter", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140005f67", + "resolved_target": "0x303ca", + "name": "UnhandledExceptionFilter", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140005f79", + "resolved_target": "0x140005e38", + "name": "", + "library": "" + }, + { + "instruction": "0x140005f9e", + "resolved_target": "0x304e4", + "name": "GetModuleHandleW", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000e8dd", + "resolved_target": "0x14001e3a0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000e915", + "resolved_target": "0x14001e3a0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ea53", + "resolved_target": "0x304e4", + "name": "GetModuleHandleW", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000ead2", + "resolved_target": "0x14000e934", + "name": "", + "library": "" + }, + { + "instruction": "0x14000eade", + "resolved_target": "0x1400191c0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ea96", + "resolved_target": "0x14000eb40", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ead2", + "resolved_target": "0x14000e934", + "name": "", + "library": "" + }, + { + "instruction": "0x14000eade", + "resolved_target": "0x1400191c0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000eb09", + "resolved_target": "0x14000eb10", + "name": "", + "library": "" + }, + { + "instruction": "0x140001180", + "resolved_target": "0x14001ef10", + "name": "", + "library": "" + }, + { + "instruction": "0x1400011be", + "resolved_target": null, + "name": "unresolved", + "library": "" + }, + { + "instruction": "0x140001292", + "resolved_target": null, + "name": "unresolved", + "library": "" + }, + { + "instruction": "0x1400011e1", + "resolved_target": "0x140002000", + "name": "", + "library": "" + }, + { + "instruction": "0x14000125b", + "resolved_target": null, + "name": "unresolved", + "library": "" + }, + { + "instruction": "0x1400012f2", + "resolved_target": null, + "name": "unresolved", + "library": "" + }, + { + "instruction": "0x14000136d", + "resolved_target": "0x1400023f4", + "name": "", + "library": "" + }, + { + "instruction": "0x140001379", + "resolved_target": "0x140001d10", + "name": "", + "library": "" + }, + { + "instruction": "0x140001392", + "resolved_target": null, + "name": "unresolved", + "library": "" + }, + { + "instruction": "0x1400017bd", + "resolved_target": "0x140001df0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000162e", + "resolved_target": "0x140001410", + "name": "", + "library": "" + }, + { + "instruction": "0x140001649", + "resolved_target": "0x14001e3e0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000165f", + "resolved_target": "0x140001e10", + "name": "", + "library": "" + }, + { + "instruction": "0x140001682", + "resolved_target": null, + "name": "unresolved", + "library": "" + }, + { + "instruction": "0x14000169b", + "resolved_target": "0x140001e10", + "name": "", + "library": "" + }, + { + "instruction": "0x14000162e", + "resolved_target": "0x140001410", + "name": "", + "library": "" + }, + { + "instruction": "0x140001649", + "resolved_target": "0x14001e3e0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000165f", + "resolved_target": "0x140001e10", + "name": "", + "library": "" + }, + { + "instruction": "0x140001682", + "resolved_target": null, + "name": "unresolved", + "library": "" + }, + { + "instruction": "0x14000169b", + "resolved_target": "0x140001e10", + "name": "", + "library": "" + }, + { + "instruction": "0x140001682", + "resolved_target": null, + "name": "unresolved", + "library": "" + }, + { + "instruction": "0x14000169b", + "resolved_target": "0x140001e10", + "name": "", + "library": "" + }, + { + "instruction": "0x1400016d6", + "resolved_target": "0x140005170", + "name": "", + "library": "" + }, + { + "instruction": "0x140001726", + "resolved_target": "0x1400060f0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000165f", + "resolved_target": "0x140001e10", + "name": "", + "library": "" + }, + { + "instruction": "0x140001682", + "resolved_target": null, + "name": "unresolved", + "library": "" + }, + { + "instruction": "0x14000169b", + "resolved_target": "0x140001e10", + "name": "", + "library": "" + }, + { + "instruction": "0x140001767", + "resolved_target": "0x140005170", + "name": "", + "library": "" + }, + { + "instruction": "0x140001788", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x1400017d6", + "resolved_target": "0x14000afd4", + "name": "", + "library": "" + }, + { + "instruction": "0x1400017b7", + "resolved_target": "0x14000afd4", + "name": "", + "library": "" + }, + { + "instruction": "0x140002629", + "resolved_target": "0x14000448c", + "name": "", + "library": "" + }, + { + "instruction": "0x14000264e", + "resolved_target": "0x14000448c", + "name": "", + "library": "" + }, + { + "instruction": "0x140002678", + "resolved_target": "0x140004504", + "name": "", + "library": "" + }, + { + "instruction": "0x1400026ad", + "resolved_target": "0x140004650", + "name": "", + "library": "" + }, + { + "instruction": "0x1400026d7", + "resolved_target": "0x1400030cc", + "name": "", + "library": "" + }, + { + "instruction": "0x140002723", + "resolved_target": "0x14000348c", + "name": "", + "library": "" + }, + { + "instruction": "0x1400026ef", + "resolved_target": "0x140004614", + "name": "", + "library": "" + }, + { + "instruction": "0x1400026fe", + "resolved_target": "0x14001e360", + "name": "", + "library": "" + }, + { + "instruction": "0x140002710", + "resolved_target": "0x140004504", + "name": "", + "library": "" + }, + { + "instruction": "0x140002710", + "resolved_target": "0x140004504", + "name": "", + "library": "" + }, + { + "instruction": "0x140002741", + "resolved_target": "0x14000448c", + "name": "", + "library": "" + }, + { + "instruction": "0x140002766", + "resolved_target": "0x14000448c", + "name": "", + "library": "" + }, + { + "instruction": "0x140002790", + "resolved_target": "0x140004504", + "name": "", + "library": "" + }, + { + "instruction": "0x1400027c5", + "resolved_target": "0x140004650", + "name": "", + "library": "" + }, + { + "instruction": "0x1400027ef", + "resolved_target": "0x140003188", + "name": "", + "library": "" + }, + { + "instruction": "0x14000283b", + "resolved_target": "0x14000348c", + "name": "", + "library": "" + }, + { + "instruction": "0x140002807", + "resolved_target": "0x140004614", + "name": "", + "library": "" + }, + { + "instruction": "0x140002816", + "resolved_target": "0x14001e360", + "name": "", + "library": "" + }, + { + "instruction": "0x140002828", + "resolved_target": "0x140004504", + "name": "", + "library": "" + }, + { + "instruction": "0x140002828", + "resolved_target": "0x140004504", + "name": "", + "library": "" + }, + { + "instruction": "0x140003953", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140003f82", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x1400049ef", + "resolved_target": "0x14000cfb8", + "name": "", + "library": "" + }, + { + "instruction": "0x1400049f8", + "resolved_target": "0x14000cf88", + "name": "", + "library": "" + }, + { + "instruction": "0x140004e6c", + "resolved_target": "0x14000d9c0", + "name": "", + "library": "" + }, + { + "instruction": "0x140004e9e", + "resolved_target": "0x3032e", + "name": "MultiByteToWideChar", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140004e9e", + "resolved_target": "0x3032e", + "name": "MultiByteToWideChar", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140004f5f", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140004f05", + "resolved_target": "0x14000cac0", + "name": "", + "library": "" + }, + { + "instruction": "0x140004eeb", + "resolved_target": "0x1400057a0", + "name": "", + "library": "" + }, + { + "instruction": "0x140004eeb", + "resolved_target": "0x1400057a0", + "name": "", + "library": "" + }, + { + "instruction": "0x140004f39", + "resolved_target": "0x3032e", + "name": "MultiByteToWideChar", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140004f51", + "resolved_target": "0x14000c9d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140004f5f", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140005d5f", + "resolved_target": "0x3048e", + "name": "GetSystemTimeAsFileTime", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140005d6d", + "resolved_target": "0x30478", + "name": "GetCurrentThreadId", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140005d79", + "resolved_target": "0x30462", + "name": "GetCurrentProcessId", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140005d89", + "resolved_target": "0x30448", + "name": "QueryPerformanceCounter", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140005e60", + "resolved_target": "0x3042c", + "name": "IsProcessorFeaturePresent", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x1400069f0", + "resolved_target": "0x3052c", + "name": "RtlUnwindEx", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x1400069fd", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140006b10", + "resolved_target": "0x3052c", + "name": "RtlUnwindEx", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140006b1d", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140007ce5", + "resolved_target": "0x140006544", + "name": "", + "library": "" + }, + { + "instruction": "0x140007d21", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140007d69", + "resolved_target": "0x140006908", + "name": "", + "library": "" + }, + { + "instruction": "0x140007d0b", + "resolved_target": "0x140007b2c", + "name": "", + "library": "" + }, + { + "instruction": "0x140007d21", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140007d69", + "resolved_target": "0x140006908", + "name": "", + "library": "" + }, + { + "instruction": "0x140007dbd", + "resolved_target": "0x14000662c", + "name": "", + "library": "" + }, + { + "instruction": "0x140007df9", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140007e41", + "resolved_target": "0x140006a0c", + "name": "", + "library": "" + }, + { + "instruction": "0x140007de3", + "resolved_target": "0x140007bec", + "name": "", + "library": "" + }, + { + "instruction": "0x140007df9", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140007e41", + "resolved_target": "0x140006a0c", + "name": "", + "library": "" + }, + { + "instruction": "0x140007ebd", + "resolved_target": "0x14000a25c", + "name": "", + "library": "" + }, + { + "instruction": "0x140008349", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007f13", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x1400082e9", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140007f23", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140007f2c", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140007f43", + "resolved_target": "0x140006de8", + "name": "", + "library": "" + }, + { + "instruction": "0x140008029", + "resolved_target": "0x140006650", + "name": "", + "library": "" + }, + { + "instruction": "0x1400082d1", + "resolved_target": "0x140008888", + "name": "", + "library": "" + }, + { + "instruction": "0x1400082d6", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x1400082e9", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140007f7e", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140007f8a", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140007f93", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140007fa6", + "resolved_target": "0x14000a2f4", + "name": "", + "library": "" + }, + { + "instruction": "0x140007fb2", + "resolved_target": "0x14000a3dc", + "name": "", + "library": "" + }, + { + "instruction": "0x1400082d6", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x1400082e9", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x1400080e2", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x1400080fb", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x140008111", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x140008124", + "resolved_target": "0x140008df4", + "name": "", + "library": "" + }, + { + "instruction": "0x140008326", + "resolved_target": "0x140010b70", + "name": "", + "library": "" + }, + { + "instruction": "0x1400081ec", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140008111", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x140008124", + "resolved_target": "0x140008df4", + "name": "", + "library": "" + }, + { + "instruction": "0x140008307", + "resolved_target": "0x140006f98", + "name": "", + "library": "" + }, + { + "instruction": "0x140008310", + "resolved_target": "0x140009724", + "name": "", + "library": "" + }, + { + "instruction": "0x140008320", + "resolved_target": "0x140006198", + "name": "", + "library": "" + }, + { + "instruction": "0x140008206", + "resolved_target": "0x140006478", + "name": "", + "library": "" + }, + { + "instruction": "0x140008235", + "resolved_target": "0x14000a2f4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000824f", + "resolved_target": "0x140006544", + "name": "", + "library": "" + }, + { + "instruction": "0x140008293", + "resolved_target": "0x140006908", + "name": "", + "library": "" + }, + { + "instruction": "0x140008225", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140008235", + "resolved_target": "0x14000a2f4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000824f", + "resolved_target": "0x140006544", + "name": "", + "library": "" + }, + { + "instruction": "0x140008293", + "resolved_target": "0x140006908", + "name": "", + "library": "" + }, + { + "instruction": "0x1400083ac", + "resolved_target": "0x1400075e0", + "name": "", + "library": "" + }, + { + "instruction": "0x1400083d2", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x1400083ba", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x1400083dd", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x1400083e5", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140008881", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140008477", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140008821", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140008487", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140008490", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x1400084a7", + "resolved_target": "0x140006de8", + "name": "", + "library": "" + }, + { + "instruction": "0x140008538", + "resolved_target": "0x140009604", + "name": "", + "library": "" + }, + { + "instruction": "0x140008592", + "resolved_target": "0x140006788", + "name": "", + "library": "" + }, + { + "instruction": "0x140008809", + "resolved_target": "0x140008aec", + "name": "", + "library": "" + }, + { + "instruction": "0x14000880e", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140008821", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x1400084e2", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140008603", + "resolved_target": "0x140009580", + "name": "", + "library": "" + }, + { + "instruction": "0x1400084ee", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x1400084f7", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14000850a", + "resolved_target": "0x14000a2f4", + "name": "", + "library": "" + }, + { + "instruction": "0x140008516", + "resolved_target": "0x14000a3dc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000880e", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140008821", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x1400087c3", + "resolved_target": "0x1400064a4", + "name": "", + "library": "" + }, + { + "instruction": "0x140008641", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x140008655", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000885e", + "resolved_target": "0x140010b70", + "name": "", + "library": "" + }, + { + "instruction": "0x140008864", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14000886d", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14000887b", + "resolved_target": "0x140010b70", + "name": "", + "library": "" + }, + { + "instruction": "0x14000883f", + "resolved_target": "0x140006f98", + "name": "", + "library": "" + }, + { + "instruction": "0x140008848", + "resolved_target": "0x140009724", + "name": "", + "library": "" + }, + { + "instruction": "0x140008858", + "resolved_target": "0x140006198", + "name": "", + "library": "" + }, + { + "instruction": "0x140008664", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x140008677", + "resolved_target": "0x140008f14", + "name": "", + "library": "" + }, + { + "instruction": "0x140008690", + "resolved_target": "0x140009b74", + "name": "", + "library": "" + }, + { + "instruction": "0x1400088c1", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140008975", + "resolved_target": "0x140006650", + "name": "", + "library": "" + }, + { + "instruction": "0x1400088e7", + "resolved_target": "0x302a8", + "name": "EncodePointer", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x1400088f0", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140008aac", + "resolved_target": "0x140007cb0", + "name": "", + "library": "" + }, + { + "instruction": "0x140008a2f", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140008933", + "resolved_target": "0x140006240", + "name": "", + "library": "" + }, + { + "instruction": "0x140008975", + "resolved_target": "0x140006650", + "name": "", + "library": "" + }, + { + "instruction": "0x140008aac", + "resolved_target": "0x140007cb0", + "name": "", + "library": "" + }, + { + "instruction": "0x140008a42", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140008aac", + "resolved_target": "0x140007cb0", + "name": "", + "library": "" + }, + { + "instruction": "0x140008dd3", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140008b44", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140008bc3", + "resolved_target": "0x140009604", + "name": "", + "library": "" + }, + { + "instruction": "0x140008bea", + "resolved_target": "0x140006788", + "name": "", + "library": "" + }, + { + "instruction": "0x140008b60", + "resolved_target": "0x302a8", + "name": "EncodePointer", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140008b69", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140008c5b", + "resolved_target": "0x140009580", + "name": "", + "library": "" + }, + { + "instruction": "0x140008c6c", + "resolved_target": "0x140009b74", + "name": "", + "library": "" + }, + { + "instruction": "0x140008c80", + "resolved_target": "0x140009b74", + "name": "", + "library": "" + }, + { + "instruction": "0x140008c8e", + "resolved_target": "0x140009b74", + "name": "", + "library": "" + }, + { + "instruction": "0x140008bab", + "resolved_target": "0x140006294", + "name": "", + "library": "" + }, + { + "instruction": "0x140008bc3", + "resolved_target": "0x140009604", + "name": "", + "library": "" + }, + { + "instruction": "0x140008bea", + "resolved_target": "0x140006788", + "name": "", + "library": "" + }, + { + "instruction": "0x140008d14", + "resolved_target": "0x140007d88", + "name": "", + "library": "" + }, + { + "instruction": "0x140008ca1", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140008d14", + "resolved_target": "0x140007d88", + "name": "", + "library": "" + }, + { + "instruction": "0x140008cb3", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140008d14", + "resolved_target": "0x140007d88", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a3d5", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a331", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a34a", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a362", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a377", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a389", + "resolved_target": "0x140008df4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a362", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a377", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a389", + "resolved_target": "0x140008df4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a331", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a34a", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a362", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a377", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a389", + "resolved_target": "0x140008df4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a58e", + "resolved_target": "0x14000a464", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a58e", + "resolved_target": "0x14000a464", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ad34", + "resolved_target": "0x14001ea80", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ad45", + "resolved_target": "0x14001ea80", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ad73", + "resolved_target": "0x30388", + "name": "RtlCaptureContext", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000ad8b", + "resolved_target": "0x3039c", + "name": "RtlLookupFunctionEntry", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000ad22", + "resolved_target": "0x140005e38", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ad34", + "resolved_target": "0x14001ea80", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ad45", + "resolved_target": "0x14001ea80", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ad73", + "resolved_target": "0x30388", + "name": "RtlCaptureContext", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000ad8b", + "resolved_target": "0x3039c", + "name": "RtlLookupFunctionEntry", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000adff", + "resolved_target": "0x304be", + "name": "IsDebuggerPresent", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000ae09", + "resolved_target": "0x303e6", + "name": "SetUnhandledExceptionFilter", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000ae14", + "resolved_target": "0x303ca", + "name": "UnhandledExceptionFilter", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000adc6", + "resolved_target": "0x303b6", + "name": "RtlVirtualUnwind", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000adff", + "resolved_target": "0x304be", + "name": "IsDebuggerPresent", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000ae09", + "resolved_target": "0x303e6", + "name": "SetUnhandledExceptionFilter", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000ae14", + "resolved_target": "0x303ca", + "name": "UnhandledExceptionFilter", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000ae38", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ae29", + "resolved_target": "0x140005e38", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ae38", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x14000aead", + "resolved_target": "0x14000aefc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000aed0", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000aee5", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000b378", + "resolved_target": "0x14000b210", + "name": "", + "library": "" + }, + { + "instruction": "0x14000b39d", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000b3b2", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000b5d3", + "resolved_target": "0x14000b468", + "name": "", + "library": "" + }, + { + "instruction": "0x14000b6c2", + "resolved_target": "0x14000b58c", + "name": "", + "library": "" + }, + { + "instruction": "0x14000b71b", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000b730", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000bb08", + "resolved_target": "0x14000b960", + "name": "", + "library": "" + }, + { + "instruction": "0x14000bb2d", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000bb42", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000bb95", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x14000bba0", + "resolved_target": "0x14000afb4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000c190", + "resolved_target": "0x14000bec8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000c1b5", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000c1ca", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000c2ec", + "resolved_target": "0x14000aefc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000c59d", + "resolved_target": "0x14000c2a4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000c5c3", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000c5d8", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000c797", + "resolved_target": "0x14000aefc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000c82b", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000c840", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000cb3b", + "resolved_target": "0x14000f858", + "name": "", + "library": "" + }, + { + "instruction": "0x14000cbfa", + "resolved_target": "0x1400118c4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000cc38", + "resolved_target": "0x140015a74", + "name": "", + "library": "" + }, + { + "instruction": "0x14000cc60", + "resolved_target": "0x140015200", + "name": "", + "library": "" + }, + { + "instruction": "0x14000cc90", + "resolved_target": "0x140015a74", + "name": "", + "library": "" + }, + { + "instruction": "0x14000cda1", + "resolved_target": "0x14000afd4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000cce6", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14000cd39", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14000cb8f", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14000cdb9", + "resolved_target": "0x140012358", + "name": "", + "library": "" + }, + { + "instruction": "0x14000cde9", + "resolved_target": "0x14000cac8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000e3ac", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x14000e3b8", + "resolved_target": "0x14000afb4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ea53", + "resolved_target": "0x304e4", + "name": "GetModuleHandleW", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000f3db", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x14000f825", + "resolved_target": "0x140017480", + "name": "", + "library": "" + }, + { + "instruction": "0x14000f825", + "resolved_target": "0x140017480", + "name": "", + "library": "" + }, + { + "instruction": "0x14000f878", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x14000f883", + "resolved_target": "0x14000afb4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000fc8b", + "resolved_target": "0x14000f8fc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000fc9b", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x14000fb7c", + "resolved_target": "0x14001a560", + "name": "", + "library": "" + }, + { + "instruction": "0x14000fb23", + "resolved_target": "0x14000fd80", + "name": "", + "library": "" + }, + { + "instruction": "0x14000fc9b", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x14000fbbc", + "resolved_target": "0x140011460", + "name": "", + "library": "" + }, + { + "instruction": "0x14000fbfc", + "resolved_target": "0x14001a500", + "name": "", + "library": "" + }, + { + "instruction": "0x14000fbfc", + "resolved_target": "0x14001a500", + "name": "", + "library": "" + }, + { + "instruction": "0x14000fc2a", + "resolved_target": "0x140017510", + "name": "", + "library": "" + }, + { + "instruction": "0x14000fc58", + "resolved_target": "0x14000fd80", + "name": "", + "library": "" + }, + { + "instruction": "0x14000fc8b", + "resolved_target": "0x14000f8fc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000fc9b", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x14000fdc1", + "resolved_target": "0x1400118c4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000fdf2", + "resolved_target": "0x14000f36c", + "name": "", + "library": "" + }, + { + "instruction": "0x14001002d", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x14001002d", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x14000fe53", + "resolved_target": "0x140015200", + "name": "", + "library": "" + }, + { + "instruction": "0x14000fe8f", + "resolved_target": "0x1400165b0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ff51", + "resolved_target": "0x140016050", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ff51", + "resolved_target": "0x140016050", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ffde", + "resolved_target": "0x14001e3a0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ff8a", + "resolved_target": "0x14001ee30", + "name": "", + "library": "" + }, + { + "instruction": "0x140010000", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140010015", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001002d", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140010078", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140010089", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140010096", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140010120", + "resolved_target": "0x14001ea80", + "name": "", + "library": "" + }, + { + "instruction": "0x140010150", + "resolved_target": "0x14001a500", + "name": "", + "library": "" + }, + { + "instruction": "0x1400102b3", + "resolved_target": "0x14001032c", + "name": "", + "library": "" + }, + { + "instruction": "0x1400102c3", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x14001026b", + "resolved_target": "0x14001032c", + "name": "", + "library": "" + }, + { + "instruction": "0x14001027b", + "resolved_target": "0x1400104ac", + "name": "", + "library": "" + }, + { + "instruction": "0x14001028b", + "resolved_target": "0x1400103b8", + "name": "", + "library": "" + }, + { + "instruction": "0x14001029b", + "resolved_target": "0x1400102e4", + "name": "", + "library": "" + }, + { + "instruction": "0x140010211", + "resolved_target": "0x14001032c", + "name": "", + "library": "" + }, + { + "instruction": "0x1400101c1", + "resolved_target": "0x14001032c", + "name": "", + "library": "" + }, + { + "instruction": "0x140010225", + "resolved_target": "0x1400104ac", + "name": "", + "library": "" + }, + { + "instruction": "0x1400101d5", + "resolved_target": "0x1400104ac", + "name": "", + "library": "" + }, + { + "instruction": "0x140010255", + "resolved_target": "0x1400103b8", + "name": "", + "library": "" + }, + { + "instruction": "0x140010235", + "resolved_target": "0x1400103b8", + "name": "", + "library": "" + }, + { + "instruction": "0x140010245", + "resolved_target": "0x1400102e4", + "name": "", + "library": "" + }, + { + "instruction": "0x140010255", + "resolved_target": "0x1400103b8", + "name": "", + "library": "" + }, + { + "instruction": "0x1400101e9", + "resolved_target": "0x1400103b8", + "name": "", + "library": "" + }, + { + "instruction": "0x14001029b", + "resolved_target": "0x1400102e4", + "name": "", + "library": "" + }, + { + "instruction": "0x1400109ed", + "resolved_target": "0x1400105f4", + "name": "", + "library": "" + }, + { + "instruction": "0x140010c49", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x140010c54", + "resolved_target": "0x14000afb4", + "name": "", + "library": "" + }, + { + "instruction": "0x140011406", + "resolved_target": "0x140010c10", + "name": "", + "library": "" + }, + { + "instruction": "0x14001142b", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x140011440", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x140011669", + "resolved_target": "0x140011494", + "name": "", + "library": "" + }, + { + "instruction": "0x14001167e", + "resolved_target": "0x140011514", + "name": "", + "library": "" + }, + { + "instruction": "0x1400116fe", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001170b", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140011718", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140011725", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140011732", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001173f", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001174c", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001175c", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001176c", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140011781", + "resolved_target": "0x14001155c", + "name": "", + "library": "" + }, + { + "instruction": "0x140011796", + "resolved_target": "0x1400114d4", + "name": "", + "library": "" + }, + { + "instruction": "0x1400116f1", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x1400116fe", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001170b", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140011718", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140011725", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140011732", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001173f", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001174c", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001175c", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001176c", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140011781", + "resolved_target": "0x14001155c", + "name": "", + "library": "" + }, + { + "instruction": "0x140011796", + "resolved_target": "0x1400114d4", + "name": "", + "library": "" + }, + { + "instruction": "0x140012d23", + "resolved_target": "0x3075c", + "name": "GetConsoleOutputCP", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140012d3b", + "resolved_target": "0x14000d940", + "name": "", + "library": "" + }, + { + "instruction": "0x140012e31", + "resolved_target": "0x14001e3e0", + "name": "", + "library": "" + }, + { + "instruction": "0x140013117", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140012e8b", + "resolved_target": "0x140016e74", + "name": "", + "library": "" + }, + { + "instruction": "0x140012fd6", + "resolved_target": "0x1400170bc", + "name": "", + "library": "" + }, + { + "instruction": "0x140013000", + "resolved_target": "0x305f6", + "name": "WriteFile", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140013105", + "resolved_target": "0x3053a", + "name": "GetLastError", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140013117", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140013046", + "resolved_target": "0x305f6", + "name": "WriteFile", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14001364a", + "resolved_target": "0x14000aefc", + "name": "", + "library": "" + }, + { + "instruction": "0x140013c6c", + "resolved_target": "0x140012934", + "name": "", + "library": "" + }, + { + "instruction": "0x140013db9", + "resolved_target": "0x1400057a0", + "name": "", + "library": "" + }, + { + "instruction": "0x140013ddc", + "resolved_target": "0x140012934", + "name": "", + "library": "" + }, + { + "instruction": "0x140013f0a", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140013fc8", + "resolved_target": "0x140013a8c", + "name": "", + "library": "" + }, + { + "instruction": "0x140013fee", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x140014003", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x1400148e8", + "resolved_target": "0x14000d854", + "name": "", + "library": "" + }, + { + "instruction": "0x1400148f1", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x140014f34", + "resolved_target": "0x140014d20", + "name": "", + "library": "" + }, + { + "instruction": "0x140014f5a", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x140014f6f", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x140014fd8", + "resolved_target": "0x140014e40", + "name": "", + "library": "" + }, + { + "instruction": "0x140014ffe", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x140015013", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x1400155ca", + "resolved_target": "0x140015260", + "name": "", + "library": "" + }, + { + "instruction": "0x1400155ef", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x140015604", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x1400157a2", + "resolved_target": "0x14000aefc", + "name": "", + "library": "" + }, + { + "instruction": "0x140015a5d", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140015ad4", + "resolved_target": "0x140015620", + "name": "", + "library": "" + }, + { + "instruction": "0x140015af9", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x140015ad4", + "resolved_target": "0x140015620", + "name": "", + "library": "" + }, + { + "instruction": "0x140015b0e", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x140015c38", + "resolved_target": "0x14000d89c", + "name": "", + "library": "" + }, + { + "instruction": "0x140015cb4", + "resolved_target": "0x140016050", + "name": "", + "library": "" + }, + { + "instruction": "0x140015cee", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140015cee", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140015d49", + "resolved_target": "0x14000d89c", + "name": "", + "library": "" + }, + { + "instruction": "0x140015d61", + "resolved_target": "0x140011ff0", + "name": "", + "library": "" + }, + { + "instruction": "0x140015e68", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140015e68", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140015ede", + "resolved_target": "0x140015d0c", + "name": "", + "library": "" + }, + { + "instruction": "0x140015f2d", + "resolved_target": "0x3053a", + "name": "GetLastError", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140015f4c", + "resolved_target": "0x140015d0c", + "name": "", + "library": "" + }, + { + "instruction": "0x140015ef0", + "resolved_target": "0x140011a80", + "name": "", + "library": "" + }, + { + "instruction": "0x140015efa", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140016024", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140015f64", + "resolved_target": "0x140011a80", + "name": "", + "library": "" + }, + { + "instruction": "0x140015f19", + "resolved_target": "0x14001c3c0", + "name": "", + "library": "" + }, + { + "instruction": "0x140015f9c", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140015f82", + "resolved_target": "0x140015d0c", + "name": "", + "library": "" + }, + { + "instruction": "0x140016024", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140015f9c", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001608d", + "resolved_target": "0x14000d89c", + "name": "", + "library": "" + }, + { + "instruction": "0x1400160c3", + "resolved_target": "0x14001702c", + "name": "", + "library": "" + }, + { + "instruction": "0x1400161c0", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x1400161c0", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140016227", + "resolved_target": "0x14000d9c0", + "name": "", + "library": "" + }, + { + "instruction": "0x140016266", + "resolved_target": "0x14001702c", + "name": "", + "library": "" + }, + { + "instruction": "0x140016266", + "resolved_target": "0x14001702c", + "name": "", + "library": "" + }, + { + "instruction": "0x1400164f2", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x1400164f2", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x1400164e4", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x1400164f2", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x1400162d7", + "resolved_target": "0x140015200", + "name": "", + "library": "" + }, + { + "instruction": "0x1400162b6", + "resolved_target": "0x1400057a0", + "name": "", + "library": "" + }, + { + "instruction": "0x1400162b6", + "resolved_target": "0x1400057a0", + "name": "", + "library": "" + }, + { + "instruction": "0x140016311", + "resolved_target": "0x14001702c", + "name": "", + "library": "" + }, + { + "instruction": "0x140016344", + "resolved_target": "0x1400121ec", + "name": "", + "library": "" + }, + { + "instruction": "0x1400164c5", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140016405", + "resolved_target": "0x140015200", + "name": "", + "library": "" + }, + { + "instruction": "0x14001639c", + "resolved_target": "0x1400121ec", + "name": "", + "library": "" + }, + { + "instruction": "0x1400163e7", + "resolved_target": "0x1400057a0", + "name": "", + "library": "" + }, + { + "instruction": "0x1400163e7", + "resolved_target": "0x1400057a0", + "name": "", + "library": "" + }, + { + "instruction": "0x14001644b", + "resolved_target": "0x1400121ec", + "name": "", + "library": "" + }, + { + "instruction": "0x140016479", + "resolved_target": "0x1400170bc", + "name": "", + "library": "" + }, + { + "instruction": "0x140016d71", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140017272", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x14001727d", + "resolved_target": "0x14000afb4", + "name": "", + "library": "" + }, + { + "instruction": "0x140017839", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x140017844", + "resolved_target": "0x14000afb4", + "name": "", + "library": "" + }, + { + "instruction": "0x140017c53", + "resolved_target": "0x140017a50", + "name": "", + "library": "" + }, + { + "instruction": "0x140017c29", + "resolved_target": "0x14001cea8", + "name": "", + "library": "" + }, + { + "instruction": "0x140017c98", + "resolved_target": "0x14001ea80", + "name": "", + "library": "" + }, + { + "instruction": "0x140017cc2", + "resolved_target": "0x14000d89c", + "name": "", + "library": "" + }, + { + "instruction": "0x140017f1b", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140017c98", + "resolved_target": "0x14001ea80", + "name": "", + "library": "" + }, + { + "instruction": "0x140017cc2", + "resolved_target": "0x14000d89c", + "name": "", + "library": "" + }, + { + "instruction": "0x140017d32", + "resolved_target": "0x14000d9d8", + "name": "", + "library": "" + }, + { + "instruction": "0x140017d55", + "resolved_target": "0x307de", + "name": "FindFirstFileExW", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140017d6f", + "resolved_target": "0x140017a50", + "name": "", + "library": "" + }, + { + "instruction": "0x140017d82", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140017f77", + "resolved_target": "0x30602", + "name": "GetModuleFileNameW", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140017f81", + "resolved_target": "0x3053a", + "name": "GetLastError", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140017f89", + "resolved_target": "0x14000d808", + "name": "", + "library": "" + }, + { + "instruction": "0x140018043", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140018398", + "resolved_target": "0x3037c", + "name": "GetCPInfo", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140018523", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x140018418", + "resolved_target": "0x140016050", + "name": "", + "library": "" + }, + { + "instruction": "0x14001844b", + "resolved_target": "0x140016514", + "name": "", + "library": "" + }, + { + "instruction": "0x140018484", + "resolved_target": "0x140016514", + "name": "", + "library": "" + }, + { + "instruction": "0x140018570", + "resolved_target": "0x1400187b0", + "name": "", + "library": "" + }, + { + "instruction": "0x140018577", + "resolved_target": "0x140018230", + "name": "", + "library": "" + }, + { + "instruction": "0x140018d68", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x140019b11", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140019b1d", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140019f12", + "resolved_target": "0x14000ef78", + "name": "", + "library": "" + }, + { + "instruction": "0x140019f5a", + "resolved_target": "0x140015e88", + "name": "", + "library": "" + }, + { + "instruction": "0x140019f7a", + "resolved_target": "0x140015e88", + "name": "", + "library": "" + }, + { + "instruction": "0x140019f9c", + "resolved_target": "0x140015e88", + "name": "", + "library": "" + }, + { + "instruction": "0x140019fbf", + "resolved_target": "0x140015e88", + "name": "", + "library": "" + }, + { + "instruction": "0x140019ffc", + "resolved_target": "0x140015e88", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a017", + "resolved_target": "0x140015e88", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a03c", + "resolved_target": "0x140015e88", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a05b", + "resolved_target": "0x140015e88", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a090", + "resolved_target": "0x140015e88", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a0b8", + "resolved_target": "0x140015e88", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a0db", + "resolved_target": "0x140015e88", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a0fb", + "resolved_target": "0x140015e88", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a120", + "resolved_target": "0x140015e88", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a144", + "resolved_target": "0x140015e88", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a16a", + "resolved_target": "0x140015e88", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a18b", + "resolved_target": "0x140015e88", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a1b0", + "resolved_target": "0x140015e88", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a1d1", + "resolved_target": "0x140015e88", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a1f2", + "resolved_target": "0x140015e88", + "name": "", + "library": "" + }, + { + "instruction": "0x14001bc05", + "resolved_target": "0x1400118c4", + "name": "", + "library": "" + }, + { + "instruction": "0x14001bc16", + "resolved_target": "0x1400118c4", + "name": "", + "library": "" + }, + { + "instruction": "0x14001bc5f", + "resolved_target": "0x14001bb54", + "name": "", + "library": "" + }, + { + "instruction": "0x14001bd4e", + "resolved_target": "0x30700", + "name": "GetUserDefaultLCID", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14001be48", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x14001bd78", + "resolved_target": "0x14001b9e4", + "name": "", + "library": "" + }, + { + "instruction": "0x14001bcfc", + "resolved_target": "0x1400118c4", + "name": "", + "library": "" + }, + { + "instruction": "0x14001bd35", + "resolved_target": "0x30716", + "name": "EnumSystemLocalesW", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14001bc97", + "resolved_target": "0x14001b5b0", + "name": "", + "library": "" + }, + { + "instruction": "0x14001bcbd", + "resolved_target": "0x14001bb54", + "name": "", + "library": "" + }, + { + "instruction": "0x14001bd8a", + "resolved_target": "0x30802", + "name": "IsValidCodePage", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14001bc8c", + "resolved_target": "0x14001b4e0", + "name": "", + "library": "" + }, + { + "instruction": "0x14001bda0", + "resolved_target": "0x306f0", + "name": "IsValidLocale", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14001bce7", + "resolved_target": "0x14001b5b0", + "name": "", + "library": "" + }, + { + "instruction": "0x14001bcbd", + "resolved_target": "0x14001bb54", + "name": "", + "library": "" + }, + { + "instruction": "0x14001bcdc", + "resolved_target": "0x14001b4e0", + "name": "", + "library": "" + }, + { + "instruction": "0x14001bdca", + "resolved_target": "0x140012164", + "name": "", + "library": "" + }, + { + "instruction": "0x14001bdca", + "resolved_target": "0x140012164", + "name": "", + "library": "" + }, + { + "instruction": "0x14001bde4", + "resolved_target": "0x140012164", + "name": "", + "library": "" + }, + { + "instruction": "0x14001bdfc", + "resolved_target": "0x306de", + "name": "GetLocaleInfoW", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14001be48", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x14001be18", + "resolved_target": "0x306de", + "name": "GetLocaleInfoW", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14001be33", + "resolved_target": "0x14001d3e4", + "name": "", + "library": "" + }, + { + "instruction": "0x14001c34e", + "resolved_target": "0x140016d88", + "name": "", + "library": "" + }, + { + "instruction": "0x14001c2d0", + "resolved_target": "0x140016d88", + "name": "", + "library": "" + }, + { + "instruction": "0x14001c39a", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x14001c37f", + "resolved_target": "0x140016d88", + "name": "", + "library": "" + }, + { + "instruction": "0x14001c39a", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x14001c2f1", + "resolved_target": "0x14001e3e0", + "name": "", + "library": "" + }, + { + "instruction": "0x14001c2d0", + "resolved_target": "0x140016d88", + "name": "", + "library": "" + }, + { + "instruction": "0x14001c5d8", + "resolved_target": "0x14000d89c", + "name": "", + "library": "" + }, + { + "instruction": "0x14001cf89", + "resolved_target": "0x14001d930", + "name": "", + "library": "" + }, + { + "instruction": "0x14001d165", + "resolved_target": "0x14000d89c", + "name": "", + "library": "" + }, + { + "instruction": "0x14001d1cf", + "resolved_target": "0x14000d9d8", + "name": "", + "library": "" + }, + { + "instruction": "0x14001d1e2", + "resolved_target": "0x14000d89c", + "name": "", + "library": "" + }, + { + "instruction": "0x14001d246", + "resolved_target": "0x14000d9d8", + "name": "", + "library": "" + }, + { + "instruction": "0x14001d25a", + "resolved_target": "0x3085e", + "name": "SetEnvironmentVariableW", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14001d270", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001d27f", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001d4c7", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x14001d4d2", + "resolved_target": "0x14000afb4", + "name": "", + "library": "" + }, + { + "instruction": "0x14001db70", + "resolved_target": "0x14000d9c0", + "name": "", + "library": "" + }, + { + "instruction": "0x14001db94", + "resolved_target": "0x14000d9c0", + "name": "", + "library": "" + }, + { + "instruction": "0x14001de8e", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x14001dbef", + "resolved_target": "0x3037c", + "name": "GetCPInfo", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14001de8e", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f114", + "resolved_target": "0x140006198", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f194", + "resolved_target": "0x140006198", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f1e2", + "resolved_target": "0x140002b78", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f26e", + "resolved_target": "0x140005170", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f28e", + "resolved_target": "0x140005170", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f2ce", + "resolved_target": "0x14000dfac", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f302", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f31a", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f32e", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f36e", + "resolved_target": "0x14000952c", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f373", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f3a9", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f3c1", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f3d5", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f3de", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f423", + "resolved_target": "0x140009534", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f428", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f4ab", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f4c0", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f4c9", + "resolved_target": "0x140010b70", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f4ab", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f4c0", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f4c9", + "resolved_target": "0x140010b70", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f4ea", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f511", + "resolved_target": "0x140009cfc", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f52c", + "resolved_target": "0x140006d54", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f56b", + "resolved_target": "0x140007010", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f57f", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f58f", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f579", + "resolved_target": "0x140006f98", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f57f", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f58f", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f56b", + "resolved_target": "0x140007010", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f5bf", + "resolved_target": "0x140009d94", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f5da", + "resolved_target": "0x140006d54", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f619", + "resolved_target": "0x140007010", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f62d", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f63a", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f647", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f627", + "resolved_target": "0x140006f98", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f62d", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f63a", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f647", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f619", + "resolved_target": "0x140007010", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f666", + "resolved_target": "0x140007064", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f67c", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f687", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f69f", + "resolved_target": "0x140007064", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f6b5", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f6c0", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14000b208", + "resolved_target": "0x140020018", + "name": "LeaveCriticalSection", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000ca86", + "resolved_target": "0x140020018", + "name": "LeaveCriticalSection", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14001f72c", + "resolved_target": "0x14000b204", + "name": "", + "library": "" + }, + { + "instruction": "0x14001f746", + "resolved_target": "0x14000b204", + "name": "", + "library": "" + }, + { + "instruction": "0x1400193d8", + "resolved_target": "0x140020018", + "name": "LeaveCriticalSection", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14001f8c2", + "resolved_target": "0x14000ca74", + "name": "", + "library": "" + }, + { + "instruction": "0x14000731c", + "resolved_target": "0x14000a73c", + "name": "", + "library": "" + }, + { + "instruction": "0x140010b4a", + "resolved_target": "0x14000b74c", + "name": "", + "library": "" + }, + { + "instruction": "0x14001c018", + "resolved_target": "0x14001e3a0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007348", + "resolved_target": "0x140007514", + "name": "", + "library": "" + }, + { + "instruction": "0x14000734d", + "resolved_target": "0x14000a784", + "name": "", + "library": "" + }, + { + "instruction": "0x14001edc8", + "resolved_target": null, + "name": "unresolved", + "library": "" + }, + { + "instruction": "0x14001ecd4", + "resolved_target": null, + "name": "unresolved", + "library": "" + }, + { + "instruction": "0x14001ec14", + "resolved_target": null, + "name": "unresolved", + "library": "" + }, + { + "instruction": "0x14001e3a0", + "resolved_target": "0x14001e360", + "name": "", + "library": "" + }, + { + "instruction": "0x14000e94b", + "resolved_target": "0x14000ca20", + "name": "", + "library": "" + }, + { + "instruction": "0x14000e954", + "resolved_target": "0x14000e96c", + "name": "", + "library": "" + }, + { + "instruction": "0x14000e95c", + "resolved_target": "0x14000ca74", + "name": "", + "library": "" + }, + { + "instruction": "0x1400191cc", + "resolved_target": "0x1400191a8", + "name": "", + "library": "" + }, + { + "instruction": "0x1400191da", + "resolved_target": "0x140011db4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000eb65", + "resolved_target": "0x30626", + "name": "GetModuleHandleExW", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000eb7b", + "resolved_target": "0x305c2", + "name": "GetProcAddress", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000eb97", + "resolved_target": "0x305b4", + "name": "FreeLibrary", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000eb88", + "resolved_target": "0x14001e3a0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000eb2f", + "resolved_target": "0x14000eb40", + "name": "", + "library": "" + }, + { + "instruction": "0x14000eb36", + "resolved_target": "0x30618", + "name": "ExitProcess", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000eb1c", + "resolved_target": "0x30404", + "name": "GetCurrentProcess", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000eb27", + "resolved_target": "0x30418", + "name": "TerminateProcess", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000eb2f", + "resolved_target": "0x14000eb40", + "name": "", + "library": "" + }, + { + "instruction": "0x14000eb36", + "resolved_target": "0x30618", + "name": "ExitProcess", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140002034", + "resolved_target": "0x140001ab0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000209d", + "resolved_target": "0x1400023f4", + "name": "", + "library": "" + }, + { + "instruction": "0x1400020ab", + "resolved_target": "0x140001d10", + "name": "", + "library": "" + }, + { + "instruction": "0x14000204c", + "resolved_target": null, + "name": "unresolved", + "library": "" + }, + { + "instruction": "0x1400020c9", + "resolved_target": null, + "name": "unresolved", + "library": "" + }, + { + "instruction": "0x14000209d", + "resolved_target": "0x1400023f4", + "name": "", + "library": "" + }, + { + "instruction": "0x1400020ab", + "resolved_target": "0x140001d10", + "name": "", + "library": "" + }, + { + "instruction": "0x140006f54", + "resolved_target": "0x14000747c", + "name": "", + "library": "" + }, + { + "instruction": "0x140001d36", + "resolved_target": null, + "name": "unresolved", + "library": "" + }, + { + "instruction": "0x140001dfb", + "resolved_target": "0x1400023ac", + "name": "", + "library": "" + }, + { + "instruction": "0x14001e8f6", + "resolved_target": null, + "name": "unresolved", + "library": "" + }, + { + "instruction": "0x14001e782", + "resolved_target": null, + "name": "unresolved", + "library": "" + }, + { + "instruction": "0x14001e652", + "resolved_target": null, + "name": "unresolved", + "library": "" + }, + { + "instruction": "0x140001e58", + "resolved_target": "0x14001e3e0", + "name": "", + "library": "" + }, + { + "instruction": "0x140001f66", + "resolved_target": "0x140001df0", + "name": "", + "library": "" + }, + { + "instruction": "0x140001ebc", + "resolved_target": "0x140001410", + "name": "", + "library": "" + }, + { + "instruction": "0x140001ee2", + "resolved_target": "0x14001e3e0", + "name": "", + "library": "" + }, + { + "instruction": "0x140001ef0", + "resolved_target": "0x14001e3e0", + "name": "", + "library": "" + }, + { + "instruction": "0x140001f22", + "resolved_target": "0x140005170", + "name": "", + "library": "" + }, + { + "instruction": "0x140001ebc", + "resolved_target": "0x140001410", + "name": "", + "library": "" + }, + { + "instruction": "0x140001ee2", + "resolved_target": "0x14001e3e0", + "name": "", + "library": "" + }, + { + "instruction": "0x140001ef0", + "resolved_target": "0x14001e3e0", + "name": "", + "library": "" + }, + { + "instruction": "0x140001f7f", + "resolved_target": "0x14000afd4", + "name": "", + "library": "" + }, + { + "instruction": "0x140001f22", + "resolved_target": "0x140005170", + "name": "", + "library": "" + }, + { + "instruction": "0x140011b16", + "resolved_target": "0x3066c", + "name": "HeapFree", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140011b20", + "resolved_target": "0x3053a", + "name": "GetLastError", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140011b28", + "resolved_target": "0x14000d738", + "name": "", + "library": "" + }, + { + "instruction": "0x140011b2f", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x140006118", + "resolved_target": "0x14001ef10", + "name": "", + "library": "" + }, + { + "instruction": "0x140006124", + "resolved_target": "0x14000cac0", + "name": "", + "library": "" + }, + { + "instruction": "0x140006148", + "resolved_target": "0x14000c9d0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000613a", + "resolved_target": "0x140010b90", + "name": "", + "library": "" + }, + { + "instruction": "0x140006148", + "resolved_target": "0x14000c9d0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000afdd", + "resolved_target": "0x3042c", + "name": "IsProcessorFeaturePresent", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000affd", + "resolved_target": "0x14000ace8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000b002", + "resolved_target": "0x30404", + "name": "GetCurrentProcess", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000b014", + "resolved_target": "0x140020088", + "name": "TerminateProcess", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000affd", + "resolved_target": "0x14000ace8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000b002", + "resolved_target": "0x30404", + "name": "GetCurrentProcess", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000b014", + "resolved_target": "0x140020088", + "name": "TerminateProcess", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000449b", + "resolved_target": "0x14000ca90", + "name": "", + "library": "" + }, + { + "instruction": "0x14000cab3", + "resolved_target": "0x140020018", + "name": "LeaveCriticalSection", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x1400030ff", + "resolved_target": "0x140005134", + "name": "", + "library": "" + }, + { + "instruction": "0x140003165", + "resolved_target": "0x140002bb8", + "name": "", + "library": "" + }, + { + "instruction": "0x140003138", + "resolved_target": "0x1400029cc", + "name": "", + "library": "" + }, + { + "instruction": "0x140003138", + "resolved_target": "0x1400029cc", + "name": "", + "library": "" + }, + { + "instruction": "0x140003495", + "resolved_target": "0x140002a80", + "name": "", + "library": "" + }, + { + "instruction": "0x1400034a6", + "resolved_target": "0x140006198", + "name": "", + "library": "" + }, + { + "instruction": "0x140004622", + "resolved_target": "0x14000cac0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000464a", + "resolved_target": "0x14000238c", + "name": "", + "library": "" + }, + { + "instruction": "0x1400031c3", + "resolved_target": "0x140005134", + "name": "", + "library": "" + }, + { + "instruction": "0x140003242", + "resolved_target": "0x140002bb8", + "name": "", + "library": "" + }, + { + "instruction": "0x1400031fc", + "resolved_target": "0x1400029cc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000321c", + "resolved_target": "0x140004910", + "name": "", + "library": "" + }, + { + "instruction": "0x1400031fc", + "resolved_target": "0x1400029cc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000321c", + "resolved_target": "0x140004910", + "name": "", + "library": "" + }, + { + "instruction": "0x14000cfbc", + "resolved_target": "0x1400118c4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000cfd5", + "resolved_target": "0x140015b2c", + "name": "", + "library": "" + }, + { + "instruction": "0x14000cf8c", + "resolved_target": "0x1400118c4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000cfa5", + "resolved_target": "0x140015b2c", + "name": "", + "library": "" + }, + { + "instruction": "0x14001524b", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x14001523e", + "resolved_target": "0x30660", + "name": "HeapAlloc", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14001521d", + "resolved_target": "0x1400105b0", + "name": "", + "library": "" + }, + { + "instruction": "0x140015229", + "resolved_target": "0x14000deb0", + "name": "", + "library": "" + }, + { + "instruction": "0x140006573", + "resolved_target": "0x1400075d8", + "name": "", + "library": "" + }, + { + "instruction": "0x140006dac", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140007b5a", + "resolved_target": "0x140007740", + "name": "", + "library": "" + }, + { + "instruction": "0x140007ba8", + "resolved_target": "0x140007040", + "name": "", + "library": "" + }, + { + "instruction": "0x140007b71", + "resolved_target": "0x140007040", + "name": "", + "library": "" + }, + { + "instruction": "0x140007bca", + "resolved_target": "0x14000a504", + "name": "", + "library": "" + }, + { + "instruction": "0x140007bb8", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x140007bca", + "resolved_target": "0x14000a504", + "name": "", + "library": "" + }, + { + "instruction": "0x140007b99", + "resolved_target": "0x14000a510", + "name": "", + "library": "" + }, + { + "instruction": "0x140007b81", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x140007b99", + "resolved_target": "0x14000a510", + "name": "", + "library": "" + }, + { + "instruction": "0x140007c1b", + "resolved_target": "0x140007934", + "name": "", + "library": "" + }, + { + "instruction": "0x140007c69", + "resolved_target": "0x140007040", + "name": "", + "library": "" + }, + { + "instruction": "0x140007c32", + "resolved_target": "0x140007040", + "name": "", + "library": "" + }, + { + "instruction": "0x140007c8b", + "resolved_target": "0x14000a504", + "name": "", + "library": "" + }, + { + "instruction": "0x140007c79", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x140007c8b", + "resolved_target": "0x14000a504", + "name": "", + "library": "" + }, + { + "instruction": "0x140007c5a", + "resolved_target": "0x14000a510", + "name": "", + "library": "" + }, + { + "instruction": "0x140007c42", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x140007c5a", + "resolved_target": "0x14000a510", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a27c", + "resolved_target": "0x1400075d8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a291", + "resolved_target": "0x140006544", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a29f", + "resolved_target": "0x140007564", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a2b3", + "resolved_target": "0x140007590", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a2c4", + "resolved_target": "0x14000759c", + "name": "", + "library": "" + }, + { + "instruction": "0x14000d6d4", + "resolved_target": "0x14001667c", + "name": "", + "library": "" + }, + { + "instruction": "0x14000d6e3", + "resolved_target": "0x1400166cc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000d720", + "resolved_target": "0x14000ebcc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000d6f6", + "resolved_target": "0x3042c", + "name": "IsProcessorFeaturePresent", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000d716", + "resolved_target": "0x14000ace8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000d720", + "resolved_target": "0x14000ebcc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000d716", + "resolved_target": "0x14000ace8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000d720", + "resolved_target": "0x14000ebcc", + "name": "", + "library": "" + }, + { + "instruction": "0x140007398", + "resolved_target": "0x1400073b0", + "name": "", + "library": "" + }, + { + "instruction": "0x1400073a7", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140006df1", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140006689", + "resolved_target": "0x1400075d8", + "name": "", + "library": "" + }, + { + "instruction": "0x140006780", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a3ff", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a436", + "resolved_target": "0x14000735c", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a412", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a41f", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a436", + "resolved_target": "0x14000735c", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a3ff", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140006dc0", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140008e23", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140008e3c", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140008e79", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x140008e6b", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140008e79", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x140008ea4", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x140008eb4", + "resolved_target": "0x14001efd0", + "name": "", + "library": "" + }, + { + "instruction": "0x140008e92", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140008ea4", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x140008eb4", + "resolved_target": "0x14001efd0", + "name": "", + "library": "" + }, + { + "instruction": "0x140010b74", + "resolved_target": "0x1400118c4", + "name": "", + "library": "" + }, + { + "instruction": "0x140010b89", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140010b82", + "resolved_target": "0x14001e3a0", + "name": "", + "library": "" + }, + { + "instruction": "0x140006fe0", + "resolved_target": "0x14000700c", + "name": "", + "library": "" + }, + { + "instruction": "0x140007001", + "resolved_target": "0x14001e360", + "name": "", + "library": "" + }, + { + "instruction": "0x140006229", + "resolved_target": "0x3051a", + "name": "RaiseException", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x1400061e8", + "resolved_target": "0x30506", + "name": "RtlPcToFileHeader", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140006229", + "resolved_target": "0x3051a", + "name": "RaiseException", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x1400061ce", + "resolved_target": "0x14001e360", + "name": "", + "library": "" + }, + { + "instruction": "0x140006487", + "resolved_target": "0x1400075d8", + "name": "", + "library": "" + }, + { + "instruction": "0x140006491", + "resolved_target": "0x1400062e8", + "name": "", + "library": "" + }, + { + "instruction": "0x1400067d5", + "resolved_target": "0x140006b2c", + "name": "", + "library": "" + }, + { + "instruction": "0x1400068cd", + "resolved_target": "0x140006b2c", + "name": "", + "library": "" + }, + { + "instruction": "0x1400068cd", + "resolved_target": "0x140006b2c", + "name": "", + "library": "" + }, + { + "instruction": "0x1400068cd", + "resolved_target": "0x140006b2c", + "name": "", + "library": "" + }, + { + "instruction": "0x1400095f0", + "resolved_target": "0x140009b74", + "name": "", + "library": "" + }, + { + "instruction": "0x140008f48", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140008f61", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140008fa3", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x140008f95", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140008fa3", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x140008fce", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x140008fde", + "resolved_target": "0x14001efd0", + "name": "", + "library": "" + }, + { + "instruction": "0x140008fbc", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140008fce", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x140008fde", + "resolved_target": "0x14001efd0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007ce5", + "resolved_target": "0x140006544", + "name": "", + "library": "" + }, + { + "instruction": "0x14000626a", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14000627a", + "resolved_target": "0x14001e360", + "name": "", + "library": "" + }, + { + "instruction": "0x1400062be", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x1400062ce", + "resolved_target": "0x14001e360", + "name": "", + "library": "" + }, + { + "instruction": "0x140007dbd", + "resolved_target": "0x14000662c", + "name": "", + "library": "" + }, + { + "instruction": "0x14000af21", + "resolved_target": "0x14000ac30", + "name": "", + "library": "" + }, + { + "instruction": "0x14000af73", + "resolved_target": "0x14000ac9c", + "name": "", + "library": "" + }, + { + "instruction": "0x14000afad", + "resolved_target": "0x14000afd4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000af4d", + "resolved_target": "0x14001e3a0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000af4d", + "resolved_target": "0x14001e3a0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000abdb", + "resolved_target": "0x3053a", + "name": "GetLastError", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000ac01", + "resolved_target": "0x1400119b4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ac10", + "resolved_target": "0x3054a", + "name": "SetLastError", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000ac29", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000b246", + "resolved_target": "0x14000aefc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000b482", + "resolved_target": "0x14000ca20", + "name": "", + "library": "" + }, + { + "instruction": "0x14000b533", + "resolved_target": "0x14000ca74", + "name": "", + "library": "" + }, + { + "instruction": "0x14000b52a", + "resolved_target": "0x14000b3cc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000b5d3", + "resolved_target": "0x14000b468", + "name": "", + "library": "" + }, + { + "instruction": "0x14000b9a3", + "resolved_target": "0x14000aefc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000d87c", + "resolved_target": "0x140011924", + "name": "", + "library": "" + }, + { + "instruction": "0x14000afc8", + "resolved_target": "0x14000ae60", + "name": "", + "library": "" + }, + { + "instruction": "0x14000bf14", + "resolved_target": "0x14000aefc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000f878", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x14000f883", + "resolved_target": "0x14000afb4", + "name": "", + "library": "" + }, + { + "instruction": "0x1400118c8", + "resolved_target": "0x140011924", + "name": "", + "library": "" + }, + { + "instruction": "0x1400118d7", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x14001237f", + "resolved_target": "0x140011c00", + "name": "", + "library": "" + }, + { + "instruction": "0x140012384", + "resolved_target": "0x140011bc8", + "name": "", + "library": "" + }, + { + "instruction": "0x1400123ad", + "resolved_target": "0x140011c00", + "name": "", + "library": "" + }, + { + "instruction": "0x1400123d6", + "resolved_target": "0x140011c00", + "name": "", + "library": "" + }, + { + "instruction": "0x1400123ff", + "resolved_target": "0x140011c00", + "name": "", + "library": "" + }, + { + "instruction": "0x140012428", + "resolved_target": "0x140011c00", + "name": "", + "library": "" + }, + { + "instruction": "0x140012451", + "resolved_target": "0x140011c00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001247a", + "resolved_target": "0x140011c00", + "name": "", + "library": "" + }, + { + "instruction": "0x1400124a3", + "resolved_target": "0x140011c00", + "name": "", + "library": "" + }, + { + "instruction": "0x1400124cc", + "resolved_target": "0x140011c00", + "name": "", + "library": "" + }, + { + "instruction": "0x1400124f5", + "resolved_target": "0x140011c00", + "name": "", + "library": "" + }, + { + "instruction": "0x14000cadf", + "resolved_target": "0x14000ca20", + "name": "", + "library": "" + }, + { + "instruction": "0x14000cae8", + "resolved_target": "0x14000cb08", + "name": "", + "library": "" + }, + { + "instruction": "0x14000caf2", + "resolved_target": "0x14000ca74", + "name": "", + "library": "" + }, + { + "instruction": "0x14001749b", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x1400174a6", + "resolved_target": "0x14000afb4", + "name": "", + "library": "" + }, + { + "instruction": "0x14001749b", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x1400174a6", + "resolved_target": "0x14000afb4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000f925", + "resolved_target": "0x140015200", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a586", + "resolved_target": "0x14001e2cc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000fdc1", + "resolved_target": "0x1400118c4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000fdf2", + "resolved_target": "0x14000f36c", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a526", + "resolved_target": "0x14001e2cc", + "name": "", + "library": "" + }, + { + "instruction": "0x1400165cb", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x1400165d6", + "resolved_target": "0x14000afb4", + "name": "", + "library": "" + }, + { + "instruction": "0x1400165cb", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x1400165d6", + "resolved_target": "0x14000afb4", + "name": "", + "library": "" + }, + { + "instruction": "0x140010353", + "resolved_target": "0x14001053c", + "name": "", + "library": "" + }, + { + "instruction": "0x14001036b", + "resolved_target": "0x140017510", + "name": "", + "library": "" + }, + { + "instruction": "0x140010385", + "resolved_target": "0x140017510", + "name": "", + "library": "" + }, + { + "instruction": "0x1400104d0", + "resolved_target": "0x14001053c", + "name": "", + "library": "" + }, + { + "instruction": "0x1400104f1", + "resolved_target": "0x14001a3c0", + "name": "", + "library": "" + }, + { + "instruction": "0x14001050b", + "resolved_target": "0x14001a3c0", + "name": "", + "library": "" + }, + { + "instruction": "0x1400103e8", + "resolved_target": "0x14001053c", + "name": "", + "library": "" + }, + { + "instruction": "0x140010406", + "resolved_target": "0x14000cdf4", + "name": "", + "library": "" + }, + { + "instruction": "0x140010406", + "resolved_target": "0x14000cdf4", + "name": "", + "library": "" + }, + { + "instruction": "0x14001043b", + "resolved_target": "0x140017510", + "name": "", + "library": "" + }, + { + "instruction": "0x14001045e", + "resolved_target": "0x14001a3c0", + "name": "", + "library": "" + }, + { + "instruction": "0x140010473", + "resolved_target": "0x14001a3c0", + "name": "", + "library": "" + }, + { + "instruction": "0x140010308", + "resolved_target": "0x140017510", + "name": "", + "library": "" + }, + { + "instruction": "0x14001060b", + "resolved_target": "0x14000ca20", + "name": "", + "library": "" + }, + { + "instruction": "0x140010614", + "resolved_target": "0x14001066c", + "name": "", + "library": "" + }, + { + "instruction": "0x14001061d", + "resolved_target": "0x14000ca74", + "name": "", + "library": "" + }, + { + "instruction": "0x140010c49", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x140010c54", + "resolved_target": "0x14000afb4", + "name": "", + "library": "" + }, + { + "instruction": "0x1400114ab", + "resolved_target": "0x14000ca20", + "name": "", + "library": "" + }, + { + "instruction": "0x1400114c3", + "resolved_target": "0x14000ca74", + "name": "", + "library": "" + }, + { + "instruction": "0x14001152b", + "resolved_target": "0x14000ca20", + "name": "", + "library": "" + }, + { + "instruction": "0x140011541", + "resolved_target": "0x14001185c", + "name": "", + "library": "" + }, + { + "instruction": "0x140011549", + "resolved_target": "0x14000ca74", + "name": "", + "library": "" + }, + { + "instruction": "0x140011573", + "resolved_target": "0x14000ca20", + "name": "", + "library": "" + }, + { + "instruction": "0x1400115ab", + "resolved_target": "0x14000ca74", + "name": "", + "library": "" + }, + { + "instruction": "0x1400115a3", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x1400115ab", + "resolved_target": "0x14000ca74", + "name": "", + "library": "" + }, + { + "instruction": "0x1400114eb", + "resolved_target": "0x14000ca20", + "name": "", + "library": "" + }, + { + "instruction": "0x1400114f9", + "resolved_target": "0x14001185c", + "name": "", + "library": "" + }, + { + "instruction": "0x140011501", + "resolved_target": "0x14000ca74", + "name": "", + "library": "" + }, + { + "instruction": "0x14000d952", + "resolved_target": "0x14000abc8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000d97a", + "resolved_target": "0x140015b60", + "name": "", + "library": "" + }, + { + "instruction": "0x14000d98a", + "resolved_target": "0x140015bcc", + "name": "", + "library": "" + }, + { + "instruction": "0x140016fd8", + "resolved_target": "0x140016bc8", + "name": "", + "library": "" + }, + { + "instruction": "0x140016efe", + "resolved_target": "0x140016bc8", + "name": "", + "library": "" + }, + { + "instruction": "0x140017193", + "resolved_target": "0x140020038", + "name": "WideCharToMultiByte", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140017193", + "resolved_target": "0x140020038", + "name": "WideCharToMultiByte", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14001293d", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x140012948", + "resolved_target": "0x14000afb4", + "name": "", + "library": "" + }, + { + "instruction": "0x140013ac2", + "resolved_target": "0x14000aefc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000d858", + "resolved_target": "0x140011924", + "name": "", + "library": "" + }, + { + "instruction": "0x140014e62", + "resolved_target": "0x14001949c", + "name": "", + "library": "" + }, + { + "instruction": "0x1400152bf", + "resolved_target": "0x14000aefc", + "name": "", + "library": "" + }, + { + "instruction": "0x1400152bf", + "resolved_target": "0x14000aefc", + "name": "", + "library": "" + }, + { + "instruction": "0x1400156a8", + "resolved_target": "0x14000aefc", + "name": "", + "library": "" + }, + { + "instruction": "0x1400156a8", + "resolved_target": "0x14000aefc", + "name": "", + "library": "" + }, + { + "instruction": "0x14001205a", + "resolved_target": "0x1400122e0", + "name": "", + "library": "" + }, + { + "instruction": "0x140012069", + "resolved_target": "0x306de", + "name": "GetLocaleInfoW", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140012039", + "resolved_target": "0x140011c00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001204e", + "resolved_target": "0x14001e3a0", + "name": "", + "library": "" + }, + { + "instruction": "0x140011ad5", + "resolved_target": "0x30660", + "name": "HeapAlloc", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140011ae2", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x140011ab1", + "resolved_target": "0x1400105b0", + "name": "", + "library": "" + }, + { + "instruction": "0x140011abd", + "resolved_target": "0x14000deb0", + "name": "", + "library": "" + }, + { + "instruction": "0x14001707d", + "resolved_target": "0x140020030", + "name": "MultiByteToWideChar", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14001707d", + "resolved_target": "0x140020030", + "name": "MultiByteToWideChar", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14001707d", + "resolved_target": "0x140020030", + "name": "MultiByteToWideChar", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14001707d", + "resolved_target": "0x140020030", + "name": "MultiByteToWideChar", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14001229c", + "resolved_target": "0x1400122e0", + "name": "", + "library": "" + }, + { + "instruction": "0x1400122c3", + "resolved_target": "0x306ce", + "name": "LCMapStringW", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140012236", + "resolved_target": "0x140011c00", + "name": "", + "library": "" + }, + { + "instruction": "0x140012290", + "resolved_target": "0x14001e3a0", + "name": "", + "library": "" + }, + { + "instruction": "0x14001cec5", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x14001ced0", + "resolved_target": "0x14000afb4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000da0c", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14000d810", + "resolved_target": "0x14000d854", + "name": "", + "library": "" + }, + { + "instruction": "0x14000d819", + "resolved_target": "0x14000d738", + "name": "", + "library": "" + }, + { + "instruction": "0x14000d820", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x140016534", + "resolved_target": "0x14000d89c", + "name": "", + "library": "" + }, + { + "instruction": "0x140016580", + "resolved_target": "0x1400161e0", + "name": "", + "library": "" + }, + { + "instruction": "0x1400187eb", + "resolved_target": "0x14000ca20", + "name": "", + "library": "" + }, + { + "instruction": "0x140018845", + "resolved_target": "0x14000ca74", + "name": "", + "library": "" + }, + { + "instruction": "0x140018862", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x14001889f", + "resolved_target": "0x1400118e0", + "name": "", + "library": "" + }, + { + "instruction": "0x1400188b5", + "resolved_target": "0x140018540", + "name": "", + "library": "" + }, + { + "instruction": "0x140018845", + "resolved_target": "0x14000ca74", + "name": "", + "library": "" + }, + { + "instruction": "0x140018824", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140018845", + "resolved_target": "0x14000ca74", + "name": "", + "library": "" + }, + { + "instruction": "0x14001823f", + "resolved_target": "0x14000d89c", + "name": "", + "library": "" + }, + { + "instruction": "0x14001825a", + "resolved_target": "0x3081e", + "name": "GetOEMCP", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000ef94", + "resolved_target": "0x14000dca0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000efaa", + "resolved_target": "0x140015200", + "name": "", + "library": "" + }, + { + "instruction": "0x14000efc4", + "resolved_target": "0x140017510", + "name": "", + "library": "" + }, + { + "instruction": "0x140015ede", + "resolved_target": "0x140015d0c", + "name": "", + "library": "" + }, + { + "instruction": "0x14001bb93", + "resolved_target": "0x140017230", + "name": "", + "library": "" + }, + { + "instruction": "0x14001ba6a", + "resolved_target": "0x306de", + "name": "GetLocaleInfoW", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14001ba10", + "resolved_target": "0x14001d690", + "name": "", + "library": "" + }, + { + "instruction": "0x14001ba23", + "resolved_target": "0x14001d690", + "name": "", + "library": "" + }, + { + "instruction": "0x14001ba3d", + "resolved_target": "0x306de", + "name": "GetLocaleInfoW", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14001b5bd", + "resolved_target": "0x1400118c4", + "name": "", + "library": "" + }, + { + "instruction": "0x14001b62e", + "resolved_target": "0x30716", + "name": "EnumSystemLocalesW", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14001b62e", + "resolved_target": "0x30716", + "name": "EnumSystemLocalesW", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14001b4ed", + "resolved_target": "0x1400118c4", + "name": "", + "library": "" + }, + { + "instruction": "0x14001b57e", + "resolved_target": "0x30716", + "name": "EnumSystemLocalesW", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x1400121d1", + "resolved_target": "0x14001c034", + "name": "", + "library": "" + }, + { + "instruction": "0x1400121ad", + "resolved_target": "0x140011c00", + "name": "", + "library": "" + }, + { + "instruction": "0x1400121c2", + "resolved_target": "0x14001e3a0", + "name": "", + "library": "" + }, + { + "instruction": "0x14001d3fa", + "resolved_target": "0x14001d378", + "name": "", + "library": "" + }, + { + "instruction": "0x140016dbb", + "resolved_target": "0x14001c5a0", + "name": "", + "library": "" + }, + { + "instruction": "0x14001d907", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x14001d912", + "resolved_target": "0x14000afb4", + "name": "", + "library": "" + }, + { + "instruction": "0x14001d907", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x14001d912", + "resolved_target": "0x14000afb4", + "name": "", + "library": "" + }, + { + "instruction": "0x140002b86", + "resolved_target": "0x140004cbc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000dfc5", + "resolved_target": "0x140011924", + "name": "", + "library": "" + }, + { + "instruction": "0x14000907b", + "resolved_target": "0x14000a704", + "name": "", + "library": "" + }, + { + "instruction": "0x140009080", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14000918b", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140009168", + "resolved_target": "0x1400064ac", + "name": "", + "library": "" + }, + { + "instruction": "0x140009110", + "resolved_target": "0x1400075e8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000927b", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140009133", + "resolved_target": "0x140009dc4", + "name": "", + "library": "" + }, + { + "instruction": "0x140009257", + "resolved_target": "0x140007e60", + "name": "", + "library": "" + }, + { + "instruction": "0x1400091d6", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000921b", + "resolved_target": "0x14001e360", + "name": "", + "library": "" + }, + { + "instruction": "0x140009564", + "resolved_target": "0x140009284", + "name": "", + "library": "" + }, + { + "instruction": "0x14000956b", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140009d70", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140006d61", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140006d6c", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140006da1", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140006d8d", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140007019", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140009da4", + "resolved_target": "0x140009cfc", + "name": "", + "library": "" + }, + { + "instruction": "0x140009daf", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14000708e", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140007099", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x1400070ae", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x1400070bb", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x1400070c4", + "resolved_target": "0x140010b70", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a75b", + "resolved_target": "0x14000aa38", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a775", + "resolved_target": "0x14000a784", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a75b", + "resolved_target": "0x14000aa38", + "name": "", + "library": "" + }, + { + "instruction": "0x140007523", + "resolved_target": "0x14000a954", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ca32", + "resolved_target": "0x140020010", + "name": "EnterCriticalSection", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000e9bb", + "resolved_target": "0x14001e3a0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000e9d5", + "resolved_target": "0x140010944", + "name": "", + "library": "" + }, + { + "instruction": "0x14000e9f1", + "resolved_target": "0x14000e8c0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ea04", + "resolved_target": "0x14000e8c0", + "name": "", + "library": "" + }, + { + "instruction": "0x140011de7", + "resolved_target": "0x140011c00", + "name": "", + "library": "" + }, + { + "instruction": "0x140001ad7", + "resolved_target": null, + "name": "unresolved", + "library": "" + }, + { + "instruction": "0x140001b09", + "resolved_target": "0x140002000", + "name": "", + "library": "" + }, + { + "instruction": "0x1400023b8", + "resolved_target": "0x1400022c0", + "name": "", + "library": "" + }, + { + "instruction": "0x1400023c9", + "resolved_target": "0x140006198", + "name": "", + "library": "" + }, + { + "instruction": "0x140010ba9", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x140010bb4", + "resolved_target": "0x14000afb4", + "name": "", + "library": "" + }, + { + "instruction": "0x140010ba9", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x140010bb4", + "resolved_target": "0x14000afb4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ca94", + "resolved_target": "0x140012358", + "name": "", + "library": "" + }, + { + "instruction": "0x14000caa4", + "resolved_target": "0x140020010", + "name": "EnterCriticalSection", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000514e", + "resolved_target": "0x14000cac0", + "name": "", + "library": "" + }, + { + "instruction": "0x140005142", + "resolved_target": "0x14000deb0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000514e", + "resolved_target": "0x14000cac0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000516a", + "resolved_target": "0x140001dd0", + "name": "", + "library": "" + }, + { + "instruction": "0x140005164", + "resolved_target": "0x14000238c", + "name": "", + "library": "" + }, + { + "instruction": "0x140002bc1", + "resolved_target": "0x1400047dc", + "name": "", + "library": "" + }, + { + "instruction": "0x140002bcf", + "resolved_target": "0x14000c9d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140002be5", + "resolved_target": "0x14000c9d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140002bfb", + "resolved_target": "0x14000c9d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140002c11", + "resolved_target": "0x14000c9d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140002c27", + "resolved_target": "0x14000c9d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140002c3d", + "resolved_target": "0x14000c9d0", + "name": "", + "library": "" + }, + { + "instruction": "0x1400029e3", + "resolved_target": "0x14000448c", + "name": "", + "library": "" + }, + { + "instruction": "0x140002a3d", + "resolved_target": "0x1400023d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140002a22", + "resolved_target": "0x140004770", + "name": "", + "library": "" + }, + { + "instruction": "0x140002395", + "resolved_target": "0x140002260", + "name": "", + "library": "" + }, + { + "instruction": "0x1400023a6", + "resolved_target": "0x140006198", + "name": "", + "library": "" + }, + { + "instruction": "0x14000491d", + "resolved_target": "0x14000cf88", + "name": "", + "library": "" + }, + { + "instruction": "0x14000492e", + "resolved_target": "0x14000d630", + "name": "", + "library": "" + }, + { + "instruction": "0x14000499f", + "resolved_target": "0x14000cdf4", + "name": "", + "library": "" + }, + { + "instruction": "0x1400049af", + "resolved_target": "0x14000cfb8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000493f", + "resolved_target": "0x14000cdf4", + "name": "", + "library": "" + }, + { + "instruction": "0x1400049c1", + "resolved_target": "0x14000d640", + "name": "", + "library": "" + }, + { + "instruction": "0x1400049af", + "resolved_target": "0x14000cfb8", + "name": "", + "library": "" + }, + { + "instruction": "0x140015b4f", + "resolved_target": "0x14001a8ec", + "name": "", + "library": "" + }, + { + "instruction": "0x14000debd", + "resolved_target": "0x14000df00", + "name": "", + "library": "" + }, + { + "instruction": "0x14000decc", + "resolved_target": "0x14001e3a0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007648", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007770", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140007790", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140007917", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000791c", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007921", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007926", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000792c", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x1400077da", + "resolved_target": "0x14001e360", + "name": "", + "library": "" + }, + { + "instruction": "0x140007872", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000791c", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007921", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007926", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000792c", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007912", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007917", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000791c", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007921", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007926", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000792c", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007921", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007926", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000792c", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000783d", + "resolved_target": "0x14001e3e0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000785d", + "resolved_target": "0x140007040", + "name": "", + "library": "" + }, + { + "instruction": "0x1400078a4", + "resolved_target": "0x140007040", + "name": "", + "library": "" + }, + { + "instruction": "0x1400078b2", + "resolved_target": "0x14001e3e0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000785d", + "resolved_target": "0x140007040", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a51c", + "resolved_target": null, + "name": "unresolved", + "library": "" + }, + { + "instruction": "0x140007964", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140007984", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140007b0e", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007b13", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007b18", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007b1d", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007b23", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x1400079d0", + "resolved_target": "0x14001e360", + "name": "", + "library": "" + }, + { + "instruction": "0x140007a69", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x140007b13", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007b18", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007b1d", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007b23", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007b09", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007b0e", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007b13", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007b18", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007b1d", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007b23", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007b18", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007b1d", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007b23", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007a34", + "resolved_target": "0x14001e3e0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007a54", + "resolved_target": "0x140007040", + "name": "", + "library": "" + }, + { + "instruction": "0x140007a9b", + "resolved_target": "0x140007040", + "name": "", + "library": "" + }, + { + "instruction": "0x140007aa9", + "resolved_target": "0x14001e3e0", + "name": "", + "library": "" + }, + { + "instruction": "0x140007a54", + "resolved_target": "0x140007040", + "name": "", + "library": "" + }, + { + "instruction": "0x140007572", + "resolved_target": "0x140006544", + "name": "", + "library": "" + }, + { + "instruction": "0x1400075b1", + "resolved_target": "0x140006544", + "name": "", + "library": "" + }, + { + "instruction": "0x1400166a0", + "resolved_target": "0x140016634", + "name": "", + "library": "" + }, + { + "instruction": "0x140016753", + "resolved_target": "0x140011924", + "name": "", + "library": "" + }, + { + "instruction": "0x1400167f3", + "resolved_target": "0x14000ca20", + "name": "", + "library": "" + }, + { + "instruction": "0x1400168b8", + "resolved_target": "0x14000ca74", + "name": "", + "library": "" + }, + { + "instruction": "0x140016921", + "resolved_target": "0x14000ebcc", + "name": "", + "library": "" + }, + { + "instruction": "0x140016917", + "resolved_target": "0x14000ca74", + "name": "", + "library": "" + }, + { + "instruction": "0x140016921", + "resolved_target": "0x14000ebcc", + "name": "", + "library": "" + }, + { + "instruction": "0x14001684a", + "resolved_target": "0x1400118c4", + "name": "", + "library": "" + }, + { + "instruction": "0x14001685a", + "resolved_target": "0x1400118c4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000630d", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ac4c", + "resolved_target": "0x3053a", + "name": "GetLastError", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000ac72", + "resolved_target": "0x1400119b4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ac81", + "resolved_target": "0x3054a", + "name": "SetLastError", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000acb8", + "resolved_target": "0x3053a", + "name": "GetLastError", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000acc8", + "resolved_target": "0x3054a", + "name": "SetLastError", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x1400119ed", + "resolved_target": "0x1400117a4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000b3e4", + "resolved_target": "0x14000b1f8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000b458", + "resolved_target": "0x14000b204", + "name": "", + "library": "" + }, + { + "instruction": "0x14000b43c", + "resolved_target": "0x14000b678", + "name": "", + "library": "" + }, + { + "instruction": "0x14000b458", + "resolved_target": "0x14000b204", + "name": "", + "library": "" + }, + { + "instruction": "0x14001196d", + "resolved_target": "0x3053a", + "name": "GetLastError", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x1400119a0", + "resolved_target": "0x3054a", + "name": "SetLastError", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140011996", + "resolved_target": "0x1400117a4", + "name": "", + "library": "" + }, + { + "instruction": "0x1400119a0", + "resolved_target": "0x3054a", + "name": "SetLastError", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140011963", + "resolved_target": "0x1400117a4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000aead", + "resolved_target": "0x14000aefc", + "name": "", + "library": "" + }, + { + "instruction": "0x140011cf9", + "resolved_target": "0x14000ca20", + "name": "", + "library": "" + }, + { + "instruction": "0x140011d1d", + "resolved_target": "0x306aa", + "name": "VirtualProtect", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140011dac", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140011d4e", + "resolved_target": "0x306aa", + "name": "VirtualProtect", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140011c6d", + "resolved_target": "0x305d4", + "name": "LoadLibraryExW", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140011c7f", + "resolved_target": "0x3053a", + "name": "GetLastError", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140011c9a", + "resolved_target": "0x140011460", + "name": "", + "library": "" + }, + { + "instruction": "0x140011d5a", + "resolved_target": "0x14000ca74", + "name": "", + "library": "" + }, + { + "instruction": "0x140011cf9", + "resolved_target": "0x14000ca20", + "name": "", + "library": "" + }, + { + "instruction": "0x140011d1d", + "resolved_target": "0x306aa", + "name": "VirtualProtect", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140011cb0", + "resolved_target": "0x140011460", + "name": "", + "library": "" + }, + { + "instruction": "0x140011cf9", + "resolved_target": "0x14000ca20", + "name": "", + "library": "" + }, + { + "instruction": "0x140011d1d", + "resolved_target": "0x306aa", + "name": "VirtualProtect", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140011cc1", + "resolved_target": "0x305d4", + "name": "LoadLibraryExW", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140011cf9", + "resolved_target": "0x14000ca20", + "name": "", + "library": "" + }, + { + "instruction": "0x140011d1d", + "resolved_target": "0x306aa", + "name": "VirtualProtect", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000cb3b", + "resolved_target": "0x14000f858", + "name": "", + "library": "" + }, + { + "instruction": "0x140010563", + "resolved_target": "0x14000cdf4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000cdf8", + "resolved_target": "0x1400118c4", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ce11", + "resolved_target": "0x140015b2c", + "name": "", + "library": "" + }, + { + "instruction": "0x14001071e", + "resolved_target": "0x14001be60", + "name": "", + "library": "" + }, + { + "instruction": "0x140010728", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x1400106fa", + "resolved_target": "0x14001be60", + "name": "", + "library": "" + }, + { + "instruction": "0x140010704", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001071e", + "resolved_target": "0x14001be60", + "name": "", + "library": "" + }, + { + "instruction": "0x140010728", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140011878", + "resolved_target": "0x14001a844", + "name": "", + "library": "" + }, + { + "instruction": "0x1400118b3", + "resolved_target": "0x14001a5b8", + "name": "", + "library": "" + }, + { + "instruction": "0x14001189f", + "resolved_target": "0x14001a644", + "name": "", + "library": "" + }, + { + "instruction": "0x140015b87", + "resolved_target": "0x14001a8ec", + "name": "", + "library": "" + }, + { + "instruction": "0x140015bf3", + "resolved_target": "0x1400188c8", + "name": "", + "library": "" + }, + { + "instruction": "0x1400194a5", + "resolved_target": "0x14000d854", + "name": "", + "library": "" + }, + { + "instruction": "0x1400194ad", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x140012332", + "resolved_target": "0x14001c11c", + "name": "", + "library": "" + }, + { + "instruction": "0x140012319", + "resolved_target": "0x140011c00", + "name": "", + "library": "" + }, + { + "instruction": "0x140012328", + "resolved_target": "0x14001e3a0", + "name": "", + "library": "" + }, + { + "instruction": "0x14001191c", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x14001190d", + "resolved_target": "0x1400117a4", + "name": "", + "library": "" + }, + { + "instruction": "0x140018570", + "resolved_target": "0x1400187b0", + "name": "", + "library": "" + }, + { + "instruction": "0x140018577", + "resolved_target": "0x140018230", + "name": "", + "library": "" + }, + { + "instruction": "0x1400171ae", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x1400171b9", + "resolved_target": "0x14000afb4", + "name": "", + "library": "" + }, + { + "instruction": "0x1400171ae", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x1400171b9", + "resolved_target": "0x14000afb4", + "name": "", + "library": "" + }, + { + "instruction": "0x14001c0dc", + "resolved_target": "0x14000dca0", + "name": "", + "library": "" + }, + { + "instruction": "0x14001c0f5", + "resolved_target": "0x1400165b0", + "name": "", + "library": "" + }, + { + "instruction": "0x14001d388", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x14001d394", + "resolved_target": "0x14000afb4", + "name": "", + "library": "" + }, + { + "instruction": "0x140004ce1", + "resolved_target": "0x140004d34", + "name": "", + "library": "" + }, + { + "instruction": "0x140004d26", + "resolved_target": "0x140005170", + "name": "", + "library": "" + }, + { + "instruction": "0x140004cff", + "resolved_target": "0x14001e360", + "name": "", + "library": "" + }, + { + "instruction": "0x140004d18", + "resolved_target": "0x14001e360", + "name": "", + "library": "" + }, + { + "instruction": "0x140004d26", + "resolved_target": "0x140005170", + "name": "", + "library": "" + }, + { + "instruction": "0x1400064c6", + "resolved_target": "0x140006544", + "name": "", + "library": "" + }, + { + "instruction": "0x1400064d4", + "resolved_target": "0x1400075d8", + "name": "", + "library": "" + }, + { + "instruction": "0x1400064de", + "resolved_target": "0x1400062e8", + "name": "", + "library": "" + }, + { + "instruction": "0x1400064fb", + "resolved_target": "0x140009dc4", + "name": "", + "library": "" + }, + { + "instruction": "0x140009dee", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140009e04", + "resolved_target": "0x14000753c", + "name": "", + "library": "" + }, + { + "instruction": "0x140009e0b", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140009f06", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140009f11", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140009e37", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140009e55", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140009f2c", + "resolved_target": "0x140007590", + "name": "", + "library": "" + }, + { + "instruction": "0x140009e68", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140009e75", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140009f47", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140009e8f", + "resolved_target": "0x140007590", + "name": "", + "library": "" + }, + { + "instruction": "0x140009e98", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140009ed0", + "resolved_target": "0x14000aae0", + "name": "", + "library": "" + }, + { + "instruction": "0x140009ed8", + "resolved_target": "0x140006dd0", + "name": "", + "library": "" + }, + { + "instruction": "0x140009eab", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140009eb8", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140009ed0", + "resolved_target": "0x14000aae0", + "name": "", + "library": "" + }, + { + "instruction": "0x140009ed8", + "resolved_target": "0x140006dd0", + "name": "", + "library": "" + }, + { + "instruction": "0x1400092b3", + "resolved_target": "0x14000a704", + "name": "", + "library": "" + }, + { + "instruction": "0x1400092b8", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140009441", + "resolved_target": "0x140009604", + "name": "", + "library": "" + }, + { + "instruction": "0x1400094f7", + "resolved_target": "0x140008350", + "name": "", + "library": "" + }, + { + "instruction": "0x140009476", + "resolved_target": "0x140006dbc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000942b", + "resolved_target": "0x140006510", + "name": "", + "library": "" + }, + { + "instruction": "0x140009378", + "resolved_target": "0x140007650", + "name": "", + "library": "" + }, + { + "instruction": "0x1400094bb", + "resolved_target": "0x14001e360", + "name": "", + "library": "" + }, + { + "instruction": "0x140009523", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x1400093cc", + "resolved_target": "0x140009f50", + "name": "", + "library": "" + }, + { + "instruction": "0x1400093cc", + "resolved_target": "0x140009f50", + "name": "", + "library": "" + }, + { + "instruction": "0x14000aa69", + "resolved_target": "0x14000a7bc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000aa83", + "resolved_target": "0x3055a", + "name": "InitializeCriticalSectionAndSpinCount", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000aa7b", + "resolved_target": "0x14001e360", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a976", + "resolved_target": "0x14000a7bc", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a993", + "resolved_target": "0x140020128", + "name": "TlsFree", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000a987", + "resolved_target": "0x14001e360", + "name": "", + "library": "" + }, + { + "instruction": "0x14001097c", + "resolved_target": "0x140010630", + "name": "", + "library": "" + }, + { + "instruction": "0x1400022ef", + "resolved_target": "0x1400060f0", + "name": "", + "library": "" + }, + { + "instruction": "0x140001dd9", + "resolved_target": "0x1400018b0", + "name": "", + "library": "" + }, + { + "instruction": "0x140001dea", + "resolved_target": "0x140006198", + "name": "", + "library": "" + }, + { + "instruction": "0x1400047eb", + "resolved_target": "0x14000cda8", + "name": "", + "library": "" + }, + { + "instruction": "0x1400023dc", + "resolved_target": "0x140002344", + "name": "", + "library": "" + }, + { + "instruction": "0x1400023ed", + "resolved_target": "0x140006198", + "name": "", + "library": "" + }, + { + "instruction": "0x140004784", + "resolved_target": "0x14000cda8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000479e", + "resolved_target": "0x140004538", + "name": "", + "library": "" + }, + { + "instruction": "0x1400047ad", + "resolved_target": "0x14000cda8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000455a", + "resolved_target": "0x14000c9d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140004585", + "resolved_target": "0x14000cac0", + "name": "", + "library": "" + }, + { + "instruction": "0x140004585", + "resolved_target": "0x14000cac0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000459b", + "resolved_target": "0x14001e3e0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000d671", + "resolved_target": "0x14000cac0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000d687", + "resolved_target": "0x1400165b0", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a8f6", + "resolved_target": "0x1400118c4", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a91f", + "resolved_target": "0x14000ca20", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a92f", + "resolved_target": "0x14001a95c", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a93c", + "resolved_target": "0x14000ca74", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a91f", + "resolved_target": "0x14000ca20", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a92f", + "resolved_target": "0x14001a95c", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a93c", + "resolved_target": "0x14000ca74", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a954", + "resolved_target": "0x14000d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000df08", + "resolved_target": "0x14000ca20", + "name": "", + "library": "" + }, + { + "instruction": "0x14000df29", + "resolved_target": "0x14000ca74", + "name": "", + "library": "" + }, + { + "instruction": "0x140016648", + "resolved_target": "0x14000ca20", + "name": "", + "library": "" + }, + { + "instruction": "0x140016669", + "resolved_target": "0x14000ca74", + "name": "", + "library": "" + }, + { + "instruction": "0x1400117b3", + "resolved_target": "0x3053a", + "name": "GetLastError", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x1400117c5", + "resolved_target": "0x140011fe8", + "name": "", + "library": "" + }, + { + "instruction": "0x1400117d2", + "resolved_target": "0x3054a", + "name": "SetLastError", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000b1fc", + "resolved_target": "0x140020010", + "name": "EnterCriticalSection", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000b6c2", + "resolved_target": "0x14000b58c", + "name": "", + "library": "" + }, + { + "instruction": "0x14001be90", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x14001beba", + "resolved_target": "0x140016930", + "name": "", + "library": "" + }, + { + "instruction": "0x14001bea4", + "resolved_target": "0x14001d6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x14001bed8", + "resolved_target": "0x14001ea80", + "name": "", + "library": "" + }, + { + "instruction": "0x14001beba", + "resolved_target": "0x140016930", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a8e2", + "resolved_target": "0x14001a81c", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a8e2", + "resolved_target": "0x14001a81c", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a73a", + "resolved_target": "0x14001a7e4", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a6ff", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a713", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a722", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a72e", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a73a", + "resolved_target": "0x14001a7e4", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a769", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a771", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a695", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a6a1", + "resolved_target": "0x14001952c", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a78b", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a6cf", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a6db", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a6b7", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a6c3", + "resolved_target": "0x140019b54", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a6cf", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a6db", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x1400188cc", + "resolved_target": "0x1400118c4", + "name": "", + "library": "" + }, + { + "instruction": "0x14001c16c", + "resolved_target": "0x14001d410", + "name": "", + "library": "" + }, + { + "instruction": "0x140004d73", + "resolved_target": "0x140005170", + "name": "", + "library": "" + }, + { + "instruction": "0x140004d99", + "resolved_target": "0x140005170", + "name": "", + "library": "" + }, + { + "instruction": "0x140007559", + "resolved_target": "0x1400075e8", + "name": "", + "library": "" + }, + { + "instruction": "0x14000aaf9", + "resolved_target": "0x14000a6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ab00", + "resolved_target": "0x14000a700", + "name": "", + "library": "" + }, + { + "instruction": "0x14000ab16", + "resolved_target": "0x14000a6d0", + "name": "", + "library": "" + }, + { + "instruction": "0x140006dd9", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140006538", + "resolved_target": "0x140009f50", + "name": "", + "library": "" + }, + { + "instruction": "0x140006538", + "resolved_target": "0x140009f50", + "name": "", + "library": "" + }, + { + "instruction": "0x140009f96", + "resolved_target": "0x140006da8", + "name": "", + "library": "" + }, + { + "instruction": "0x140009fa6", + "resolved_target": "0x1400075e0", + "name": "", + "library": "" + }, + { + "instruction": "0x140009fd3", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140009fbc", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140009ff2", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140009fde", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140009fe6", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x140009ff2", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a0a8", + "resolved_target": "0x14000a520", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a218", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a223", + "resolved_target": "0x140007394", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a236", + "resolved_target": "0x140005210", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a0f1", + "resolved_target": "0x14000a464", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a122", + "resolved_target": "0x14000a464", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a14f", + "resolved_target": "0x14000a5f0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a0a8", + "resolved_target": "0x14000a520", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a1b0", + "resolved_target": "0x14000aae0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a1f1", + "resolved_target": "0x140006dd0", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a841", + "resolved_target": "0x305d4", + "name": "LoadLibraryExW", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000a84f", + "resolved_target": "0x3053a", + "name": "GetLastError", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x14000a868", + "resolved_target": "0x140011460", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a879", + "resolved_target": "0x305d4", + "name": "LoadLibraryExW", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140010647", + "resolved_target": "0x14000ca20", + "name": "", + "library": "" + }, + { + "instruction": "0x140010650", + "resolved_target": "0x14001081c", + "name": "", + "library": "" + }, + { + "instruction": "0x140010659", + "resolved_target": "0x14000ca74", + "name": "", + "library": "" + }, + { + "instruction": "0x14000cdb9", + "resolved_target": "0x140012358", + "name": "", + "library": "" + }, + { + "instruction": "0x14000cde9", + "resolved_target": "0x14000cac8", + "name": "", + "library": "" + }, + { + "instruction": "0x140002373", + "resolved_target": "0x1400060f0", + "name": "", + "library": "" + }, + { + "instruction": "0x140011fe8", + "resolved_target": "0x1400201a0", + "name": "FlsSetValue", + "library": "KERNEL32.dll" + }, + { + "instruction": "0x140016948", + "resolved_target": "0x140015200", + "name": "", + "library": "" + }, + { + "instruction": "0x14001d6d9", + "resolved_target": "0x14000d878", + "name": "", + "library": "" + }, + { + "instruction": "0x14001d6e4", + "resolved_target": "0x14000afb4", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a808", + "resolved_target": "0x14001a21c", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a810", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001954a", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001955c", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001956e", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140019580", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140019592", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x1400195a4", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x1400195b6", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x1400195c8", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x1400195da", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x1400195ec", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140019601", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140019616", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001962b", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140019b6d", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140019b7f", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140019b91", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140019ba3", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140019bb5", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a648", + "resolved_target": "0x14000a464", + "name": "", + "library": "" + }, + { + "instruction": "0x14000a648", + "resolved_target": "0x14000a464", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a23e", + "resolved_target": "0x140019ea8", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a249", + "resolved_target": "0x140019ea8", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a257", + "resolved_target": "0x140019ea8", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a265", + "resolved_target": "0x140019ea8", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a274", + "resolved_target": "0x140019ea8", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a280", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a28c", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a298", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a2a6", + "resolved_target": "0x140019ea8", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a2b4", + "resolved_target": "0x140019ea8", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a2c2", + "resolved_target": "0x140019ea8", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a2d0", + "resolved_target": "0x140019ea8", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a2df", + "resolved_target": "0x140019ea8", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a2eb", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a2f7", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a303", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x14001a30f", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + }, + { + "instruction": "0x140019ec1", + "resolved_target": "0x140011b00", + "name": "", + "library": "" + } + ], + "functions": [ + { + "address": "0x1400054bc", + "name": "entry", + "blocks": [ + { + "address": "0x1400054bc", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400054bc", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400054c0", + "size": 5, + "mnemonic": "call", + "operands": "0x140005d30" + }, + { + "address": "0x1400054c5", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400054c9", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140005340" + } + ], + "successors": [ + "0x140005340" + ] + }, + { + "address": "0x140005340", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005340", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140005345", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rsi" + }, + { + "address": "0x14000534a", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000534b", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000534f", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 1" + }, + { + "address": "0x140005354", + "size": 5, + "mnemonic": "call", + "operands": "0x14000550c" + }, + { + "address": "0x140005359", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x14000535b", + "size": 6, + "mnemonic": "je", + "operands": "0x140005497" + } + ], + "successors": [ + "0x140005497", + "0x140005361" + ] + }, + { + "address": "0x140005497", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005497", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 7" + }, + { + "address": "0x14000549c", + "size": 5, + "mnemonic": "call", + "operands": "0x140005e44" + }, + { + "address": "0x1400054a1", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x1400054a2", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 7" + }, + { + "address": "0x1400054a7", + "size": 5, + "mnemonic": "call", + "operands": "0x140005e44" + }, + { + "address": "0x1400054ac", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x1400054ae", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ec14" + }, + { + "address": "0x1400054b3", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x1400054b4", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x1400054b6", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ebcc" + }, + { + "address": "0x1400054bb", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x1400054bc", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400054c0", + "size": 5, + "mnemonic": "call", + "operands": "0x140005d30" + }, + { + "address": "0x1400054c5", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400054c9", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140005340" + } + ], + "successors": [ + "0x140005340" + ] + }, + { + "address": "0x140005361", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005361", + "size": 3, + "mnemonic": "xor", + "operands": "sil, sil" + }, + { + "address": "0x140005364", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x20], sil" + }, + { + "address": "0x140005369", + "size": 5, + "mnemonic": "call", + "operands": "0x1400054d0" + }, + { + "address": "0x14000536e", + "size": 2, + "mnemonic": "mov", + "operands": "bl, al" + }, + { + "address": "0x140005370", + "size": 6, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rip + 0x2d37a]" + }, + { + "address": "0x140005376", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, 1" + }, + { + "address": "0x140005379", + "size": 6, + "mnemonic": "je", + "operands": "0x1400054a2" + } + ], + "successors": [ + "0x1400054a2", + "0x14000537f" + ] + }, + { + "address": "0x1400054a2", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400054a2", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 7" + }, + { + "address": "0x1400054a7", + "size": 5, + "mnemonic": "call", + "operands": "0x140005e44" + }, + { + "address": "0x1400054ac", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x1400054ae", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ec14" + }, + { + "address": "0x1400054b3", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x1400054b4", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x1400054b6", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ebcc" + }, + { + "address": "0x1400054bb", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x1400054bc", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400054c0", + "size": 5, + "mnemonic": "call", + "operands": "0x140005d30" + }, + { + "address": "0x1400054c5", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400054c9", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140005340" + } + ], + "successors": [ + "0x140005340" + ] + }, + { + "address": "0x14000537f", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000537f", + "size": 2, + "mnemonic": "test", + "operands": "ecx, ecx" + }, + { + "address": "0x140005381", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400053cd" + }, + { + "address": "0x140005383", + "size": 10, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2d363], 1" + }, + { + "address": "0x14000538d", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x1aff4]" + }, + { + "address": "0x140005394", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x1afad]" + }, + { + "address": "0x14000539b", + "size": 5, + "mnemonic": "call", + "operands": "0x14000e8f8" + }, + { + "address": "0x1400053a0", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x1400053a2", + "size": 2, + "mnemonic": "je", + "operands": "0x1400053ae" + } + ], + "successors": [ + "0x1400053ae", + "0x1400053a4" + ] + }, + { + "address": "0x1400053ae", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400053ae", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x1af8b]" + }, + { + "address": "0x1400053b5", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x1af2c]" + }, + { + "address": "0x1400053bc", + "size": 5, + "mnemonic": "call", + "operands": "0x14000e8c0" + }, + { + "address": "0x1400053c1", + "size": 10, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2d325], 2" + }, + { + "address": "0x1400053cb", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400053d5" + } + ], + "successors": [ + "0x1400053d5" + ] + }, + { + "address": "0x1400053a4", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400053a4", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0xff" + }, + { + "address": "0x1400053a9", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140005487" + } + ], + "successors": [ + "0x140005487" + ] + }, + { + "address": "0x1400053d5", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400053d5", + "size": 2, + "mnemonic": "mov", + "operands": "cl, bl" + }, + { + "address": "0x1400053d7", + "size": 5, + "mnemonic": "call", + "operands": "0x14000566c" + }, + { + "address": "0x1400053dc", + "size": 5, + "mnemonic": "call", + "operands": "0x140005e28" + }, + { + "address": "0x1400053e1", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x1400053e4", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [rax], 0" + }, + { + "address": "0x1400053e8", + "size": 2, + "mnemonic": "je", + "operands": "0x140005408" + } + ], + "successors": [ + "0x140005408", + "0x1400053ea" + ] + }, + { + "address": "0x140005487", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140005487", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14000548c", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x48]" + }, + { + "address": "0x140005491", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140005495", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140005496", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140005408", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005408", + "size": 5, + "mnemonic": "call", + "operands": "0x140005e30" + }, + { + "address": "0x14000540d", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x140005410", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [rax], 0" + }, + { + "address": "0x140005414", + "size": 2, + "mnemonic": "je", + "operands": "0x14000542a" + } + ], + "successors": [ + "0x14000542a", + "0x140005416" + ] + }, + { + "address": "0x1400053ea", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400053ea", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x1400053ed", + "size": 5, + "mnemonic": "call", + "operands": "0x1400055d4" + }, + { + "address": "0x1400053f2", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x1400053f4", + "size": 2, + "mnemonic": "je", + "operands": "0x140005408" + } + ], + "successors": [ + "0x140005408", + "0x1400053f6" + ] + }, + { + "address": "0x14000542a", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000542a", + "size": 5, + "mnemonic": "call", + "operands": "0x14000e868" + }, + { + "address": "0x14000542f", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rax" + }, + { + "address": "0x140005432", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ec90" + }, + { + "address": "0x140005437", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rax]" + }, + { + "address": "0x14000543a", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ec88" + }, + { + "address": "0x14000543f", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rdi" + }, + { + "address": "0x140005442", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x140005445", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rax]" + }, + { + "address": "0x140005447", + "size": 5, + "mnemonic": "call", + "operands": "0x140002240" + }, + { + "address": "0x14000544c", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, eax" + }, + { + "address": "0x14000544e", + "size": 5, + "mnemonic": "call", + "operands": "0x140005f98" + }, + { + "address": "0x140005453", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x140005455", + "size": 2, + "mnemonic": "je", + "operands": "0x1400054ac" + } + ], + "successors": [ + "0x1400054ac", + "0x140005457" + ] + }, + { + "address": "0x140005416", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005416", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x140005419", + "size": 5, + "mnemonic": "call", + "operands": "0x1400055d4" + }, + { + "address": "0x14000541e", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x140005420", + "size": 2, + "mnemonic": "je", + "operands": "0x14000542a" + } + ], + "successors": [ + "0x14000542a", + "0x140005422" + ] + }, + { + "address": "0x1400053f6", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400053f6", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x1400053f9", + "size": 4, + "mnemonic": "lea", + "operands": "edx, [r8 + 2]" + }, + { + "address": "0x1400053fd", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x1400053ff", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx]" + }, + { + "address": "0x140005402", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1aeb8]" + }, + { + "address": "0x140005408", + "size": 5, + "mnemonic": "call", + "operands": "0x140005e30" + }, + { + "address": "0x14000540d", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x140005410", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [rax], 0" + }, + { + "address": "0x140005414", + "size": 2, + "mnemonic": "je", + "operands": "0x14000542a" + } + ], + "successors": [ + "0x14000542a", + "0x140005416" + ] + }, + { + "address": "0x1400054ac", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400054ac", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x1400054ae", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ec14" + }, + { + "address": "0x1400054b3", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x1400054b4", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x1400054b6", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ebcc" + }, + { + "address": "0x1400054bb", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x1400054bc", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400054c0", + "size": 5, + "mnemonic": "call", + "operands": "0x140005d30" + }, + { + "address": "0x1400054c5", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400054c9", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140005340" + } + ], + "successors": [ + "0x140005340" + ] + }, + { + "address": "0x140005457", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005457", + "size": 3, + "mnemonic": "test", + "operands": "sil, sil" + }, + { + "address": "0x14000545a", + "size": 2, + "mnemonic": "jne", + "operands": "0x140005461" + }, + { + "address": "0x14000545c", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ebbc" + }, + { + "address": "0x140005461", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140005463", + "size": 2, + "mnemonic": "mov", + "operands": "cl, 1" + }, + { + "address": "0x140005465", + "size": 5, + "mnemonic": "call", + "operands": "0x140005690" + }, + { + "address": "0x14000546a", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ebx" + }, + { + "address": "0x14000546c", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140005487" + } + ], + "successors": [ + "0x140005487" + ] + }, + { + "address": "0x140005422", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005422", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx]" + }, + { + "address": "0x140005425", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ebd8" + }, + { + "address": "0x14000542a", + "size": 5, + "mnemonic": "call", + "operands": "0x14000e868" + }, + { + "address": "0x14000542f", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rax" + }, + { + "address": "0x140005432", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ec90" + }, + { + "address": "0x140005437", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rax]" + }, + { + "address": "0x14000543a", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ec88" + }, + { + "address": "0x14000543f", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rdi" + }, + { + "address": "0x140005442", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x140005445", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rax]" + }, + { + "address": "0x140005447", + "size": 5, + "mnemonic": "call", + "operands": "0x140002240" + }, + { + "address": "0x14000544c", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, eax" + }, + { + "address": "0x14000544e", + "size": 5, + "mnemonic": "call", + "operands": "0x140005f98" + }, + { + "address": "0x140005453", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x140005455", + "size": 2, + "mnemonic": "je", + "operands": "0x1400054ac" + } + ], + "successors": [ + "0x1400054ac", + "0x140005457" + ] + } + ] + }, + { + "address": "0x140002240", + "name": "", + "blocks": [ + { + "address": "0x140002240", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140002240", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x140002244", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x1e32d]" + }, + { + "address": "0x14000224b", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x2ff8e]" + }, + { + "address": "0x140002252", + "size": 5, + "mnemonic": "call", + "operands": "0x140001150" + }, + { + "address": "0x140002257", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140002259", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000225d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400054d0", + "name": "", + "blocks": [ + { + "address": "0x1400054d0", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400054d0", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400054d4", + "size": 5, + "mnemonic": "call", + "operands": "0x1400060d8" + }, + { + "address": "0x1400054d9", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x1400054db", + "size": 2, + "mnemonic": "je", + "operands": "0x1400054fe" + } + ], + "successors": [ + "0x1400054fe", + "0x1400054dd" + ] + }, + { + "address": "0x1400054fe", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400054fe", + "size": 2, + "mnemonic": "xor", + "operands": "al, al" + }, + { + "address": "0x140005500", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x140005504", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400054dd", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400054dd", + "size": 9, + "mnemonic": "mov", + "operands": "rax, qword ptr gs:[0x30]" + }, + { + "address": "0x1400054e6", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax + 8]" + }, + { + "address": "0x1400054ea", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400054f1" + } + ], + "successors": [ + "0x1400054f1" + ] + }, + { + "address": "0x1400054f1", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400054f1", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x1400054f3", + "size": 9, + "mnemonic": "lock cmpxchg", + "operands": "qword ptr [rip + 0x2d1fc], rcx" + }, + { + "address": "0x1400054fc", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400054ec" + }, + { + "address": "0x1400054fe", + "size": 2, + "mnemonic": "xor", + "operands": "al, al" + }, + { + "address": "0x140005500", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x140005504", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000550c", + "name": "", + "blocks": [ + { + "address": "0x14000550c", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000550c", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x140005510", + "size": 2, + "mnemonic": "test", + "operands": "ecx, ecx" + }, + { + "address": "0x140005512", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000551b" + }, + { + "address": "0x140005514", + "size": 7, + "mnemonic": "mov", + "operands": "byte ptr [rip + 0x2d1e5], 1" + }, + { + "address": "0x14000551b", + "size": 5, + "mnemonic": "call", + "operands": "0x1400057f0" + }, + { + "address": "0x140005520", + "size": 5, + "mnemonic": "call", + "operands": "0x140007318" + }, + { + "address": "0x140005525", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x140005527", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000552d" + }, + { + "address": "0x140005529", + "size": 2, + "mnemonic": "xor", + "operands": "al, al" + }, + { + "address": "0x14000552b", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140005541" + } + ], + "successors": [ + "0x140005541" + ] + }, + { + "address": "0x140005541", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140005541", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x140005545", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400055d4", + "name": "", + "blocks": [ + { + "address": "0x1400055d4", + "size": 23, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400055d4", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x18" + }, + { + "address": "0x1400055d8", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rcx" + }, + { + "address": "0x1400055db", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x5a4d" + }, + { + "address": "0x1400055e0", + "size": 7, + "mnemonic": "cmp", + "operands": "word ptr [rip - 0x55e7], ax" + }, + { + "address": "0x1400055e7", + "size": 2, + "mnemonic": "jne", + "operands": "0x140005661" + }, + { + "address": "0x1400055e9", + "size": 7, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rip - 0x55b4]" + }, + { + "address": "0x1400055f0", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip - 0x55f7]" + }, + { + "address": "0x1400055f7", + "size": 3, + "mnemonic": "add", + "operands": "rcx, rdx" + }, + { + "address": "0x1400055fa", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rcx], 0x4550" + }, + { + "address": "0x140005600", + "size": 2, + "mnemonic": "jne", + "operands": "0x140005661" + }, + { + "address": "0x140005602", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x20b" + }, + { + "address": "0x140005607", + "size": 4, + "mnemonic": "cmp", + "operands": "word ptr [rcx + 0x18], ax" + }, + { + "address": "0x14000560b", + "size": 2, + "mnemonic": "jne", + "operands": "0x140005661" + }, + { + "address": "0x14000560d", + "size": 3, + "mnemonic": "sub", + "operands": "r8, rdx" + }, + { + "address": "0x140005610", + "size": 4, + "mnemonic": "movzx", + "operands": "edx, word ptr [rcx + 0x14]" + }, + { + "address": "0x140005614", + "size": 4, + "mnemonic": "add", + "operands": "rdx, 0x18" + }, + { + "address": "0x140005618", + "size": 3, + "mnemonic": "add", + "operands": "rdx, rcx" + }, + { + "address": "0x14000561b", + "size": 4, + "mnemonic": "movzx", + "operands": "eax, word ptr [rcx + 6]" + }, + { + "address": "0x14000561f", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + rax*4]" + }, + { + "address": "0x140005623", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rdx + rcx*8]" + }, + { + "address": "0x140005627", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rsp], rdx" + }, + { + "address": "0x14000562b", + "size": 3, + "mnemonic": "cmp", + "operands": "rdx, r9" + }, + { + "address": "0x14000562e", + "size": 2, + "mnemonic": "je", + "operands": "0x140005648" + } + ], + "successors": [ + "0x140005648", + "0x140005630" + ] + }, + { + "address": "0x140005648", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005648", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000564a", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14000564d", + "size": 2, + "mnemonic": "jne", + "operands": "0x140005653" + }, + { + "address": "0x14000564f", + "size": 2, + "mnemonic": "xor", + "operands": "al, al" + }, + { + "address": "0x140005651", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140005667" + } + ], + "successors": [ + "0x140005667" + ] + }, + { + "address": "0x140005630", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005630", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rdx + 0xc]" + }, + { + "address": "0x140005633", + "size": 3, + "mnemonic": "cmp", + "operands": "r8, rcx" + }, + { + "address": "0x140005636", + "size": 2, + "mnemonic": "jb", + "operands": "0x140005642" + } + ], + "successors": [ + "0x140005642", + "0x140005638" + ] + }, + { + "address": "0x140005667", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140005667", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x18" + }, + { + "address": "0x14000566b", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140005642", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005642", + "size": 4, + "mnemonic": "add", + "operands": "rdx, 0x28" + }, + { + "address": "0x140005646", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140005627" + } + ], + "successors": [ + "0x140005627" + ] + }, + { + "address": "0x140005638", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005638", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx + 8]" + }, + { + "address": "0x14000563b", + "size": 2, + "mnemonic": "add", + "operands": "eax, ecx" + }, + { + "address": "0x14000563d", + "size": 3, + "mnemonic": "cmp", + "operands": "r8, rax" + }, + { + "address": "0x140005640", + "size": 2, + "mnemonic": "jb", + "operands": "0x14000564a" + } + ], + "successors": [ + "0x14000564a", + "0x140005642" + ] + }, + { + "address": "0x140005627", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005627", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rsp], rdx" + }, + { + "address": "0x14000562b", + "size": 3, + "mnemonic": "cmp", + "operands": "rdx, r9" + }, + { + "address": "0x14000562e", + "size": 2, + "mnemonic": "je", + "operands": "0x140005648" + } + ], + "successors": [ + "0x140005648", + "0x140005630" + ] + }, + { + "address": "0x14000564a", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000564a", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14000564d", + "size": 2, + "mnemonic": "jne", + "operands": "0x140005653" + }, + { + "address": "0x14000564f", + "size": 2, + "mnemonic": "xor", + "operands": "al, al" + }, + { + "address": "0x140005651", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140005667" + } + ], + "successors": [ + "0x140005667" + ] + } + ] + }, + { + "address": "0x14000566c", + "name": "", + "blocks": [ + { + "address": "0x14000566c", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000566c", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x14000566e", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140005672", + "size": 2, + "mnemonic": "mov", + "operands": "bl, cl" + }, + { + "address": "0x140005674", + "size": 5, + "mnemonic": "call", + "operands": "0x1400060d8" + }, + { + "address": "0x140005679", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000567b", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000567d", + "size": 2, + "mnemonic": "je", + "operands": "0x14000568a" + } + ], + "successors": [ + "0x14000568a", + "0x14000567f" + ] + }, + { + "address": "0x14000568a", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000568a", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000568e", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000568f", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000567f", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000567f", + "size": 2, + "mnemonic": "test", + "operands": "bl, bl" + }, + { + "address": "0x140005681", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000568a" + }, + { + "address": "0x140005683", + "size": 7, + "mnemonic": "xchg", + "operands": "qword ptr [rip + 0x2d06e], rdx" + }, + { + "address": "0x14000568a", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000568e", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000568f", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140005690", + "name": "", + "blocks": [ + { + "address": "0x140005690", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005690", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140005692", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140005696", + "size": 7, + "mnemonic": "cmp", + "operands": "byte ptr [rip + 0x2d063], 0" + }, + { + "address": "0x14000569d", + "size": 2, + "mnemonic": "mov", + "operands": "bl, cl" + }, + { + "address": "0x14000569f", + "size": 2, + "mnemonic": "je", + "operands": "0x1400056a5" + } + ], + "successors": [ + "0x1400056a5", + "0x1400056a1" + ] + }, + { + "address": "0x1400056a5", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400056a5", + "size": 5, + "mnemonic": "call", + "operands": "0x140010b38" + }, + { + "address": "0x1400056aa", + "size": 2, + "mnemonic": "mov", + "operands": "cl, bl" + }, + { + "address": "0x1400056ac", + "size": 5, + "mnemonic": "call", + "operands": "0x140007340" + }, + { + "address": "0x1400056b1", + "size": 2, + "mnemonic": "mov", + "operands": "al, 1" + }, + { + "address": "0x1400056b3", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400056b7", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x1400056b8", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400056a1", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400056a1", + "size": 2, + "mnemonic": "test", + "operands": "dl, dl" + }, + { + "address": "0x1400056a3", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400056b1" + }, + { + "address": "0x1400056a5", + "size": 5, + "mnemonic": "call", + "operands": "0x140010b38" + }, + { + "address": "0x1400056aa", + "size": 2, + "mnemonic": "mov", + "operands": "cl, bl" + }, + { + "address": "0x1400056ac", + "size": 5, + "mnemonic": "call", + "operands": "0x140007340" + }, + { + "address": "0x1400056b1", + "size": 2, + "mnemonic": "mov", + "operands": "al, 1" + }, + { + "address": "0x1400056b3", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400056b7", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x1400056b8", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140005d30", + "name": "", + "blocks": [ + { + "address": "0x140005d30", + "size": 39, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x140005d30", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rbx" + }, + { + "address": "0x140005d35", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140005d36", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x140005d39", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x140005d3d", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x2b2fc]" + }, + { + "address": "0x140005d44", + "size": 10, + "mnemonic": "movabs", + "operands": "rbx, 0x2b992ddfa232" + }, + { + "address": "0x140005d4e", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, rbx" + }, + { + "address": "0x140005d51", + "size": 2, + "mnemonic": "jne", + "operands": "0x140005dca" + }, + { + "address": "0x140005d53", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x10]" + }, + { + "address": "0x140005d57", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x10], 0" + }, + { + "address": "0x140005d5f", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a34b]" + }, + { + "address": "0x140005d65", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x10]" + }, + { + "address": "0x140005d69", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x10], rax" + }, + { + "address": "0x140005d6d", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a335]" + }, + { + "address": "0x140005d73", + "size": 2, + "mnemonic": "mov", + "operands": "eax, eax" + }, + { + "address": "0x140005d75", + "size": 4, + "mnemonic": "xor", + "operands": "qword ptr [rbp - 0x10], rax" + }, + { + "address": "0x140005d79", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a321]" + }, + { + "address": "0x140005d7f", + "size": 2, + "mnemonic": "mov", + "operands": "eax, eax" + }, + { + "address": "0x140005d81", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x18]" + }, + { + "address": "0x140005d85", + "size": 4, + "mnemonic": "xor", + "operands": "qword ptr [rbp - 0x10], rax" + }, + { + "address": "0x140005d89", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a309]" + }, + { + "address": "0x140005d8f", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbp + 0x18]" + }, + { + "address": "0x140005d92", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x140005d96", + "size": 4, + "mnemonic": "shl", + "operands": "rax, 0x20" + }, + { + "address": "0x140005d9a", + "size": 4, + "mnemonic": "xor", + "operands": "rax, qword ptr [rbp + 0x18]" + }, + { + "address": "0x140005d9e", + "size": 4, + "mnemonic": "xor", + "operands": "rax, qword ptr [rbp - 0x10]" + }, + { + "address": "0x140005da2", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rcx" + }, + { + "address": "0x140005da5", + "size": 10, + "mnemonic": "movabs", + "operands": "rcx, 0xffffffffffff" + }, + { + "address": "0x140005daf", + "size": 3, + "mnemonic": "and", + "operands": "rax, rcx" + }, + { + "address": "0x140005db2", + "size": 10, + "mnemonic": "movabs", + "operands": "rcx, 0x2b992ddfa233" + }, + { + "address": "0x140005dbc", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, rbx" + }, + { + "address": "0x140005dbf", + "size": 4, + "mnemonic": "cmove", + "operands": "rax, rcx" + }, + { + "address": "0x140005dc3", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x2b276], rax" + }, + { + "address": "0x140005dca", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x50]" + }, + { + "address": "0x140005dcf", + "size": 3, + "mnemonic": "not", + "operands": "rax" + }, + { + "address": "0x140005dd2", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x2b2a7], rax" + }, + { + "address": "0x140005dd9", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140005ddd", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140005dde", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140005e28", + "name": "", + "blocks": [ + { + "address": "0x140005e28", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140005e28", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x2da49]" + }, + { + "address": "0x140005e2f", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140005e30", + "name": "", + "blocks": [ + { + "address": "0x140005e30", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140005e30", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x2da39]" + }, + { + "address": "0x140005e37", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140005e44", + "name": "", + "blocks": [ + { + "address": "0x140005e44", + "size": 9, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005e44", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140005e49", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140005e4a", + "size": 8, + "mnemonic": "lea", + "operands": "rbp, [rsp - 0x4c0]" + }, + { + "address": "0x140005e52", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x5c0" + }, + { + "address": "0x140005e59", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, ecx" + }, + { + "address": "0x140005e5b", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0x17" + }, + { + "address": "0x140005e60", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a22a]" + }, + { + "address": "0x140005e66", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140005e68", + "size": 2, + "mnemonic": "je", + "operands": "0x140005e6e" + } + ], + "successors": [ + "0x140005e6e", + "0x140005e6a" + ] + }, + { + "address": "0x140005e6e", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005e6e", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 3" + }, + { + "address": "0x140005e73", + "size": 5, + "mnemonic": "call", + "operands": "0x140005e38" + }, + { + "address": "0x140005e78", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140005e7a", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x140005e7e", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x4d0" + }, + { + "address": "0x140005e84", + "size": 5, + "mnemonic": "call", + "operands": "0x14001ea80" + }, + { + "address": "0x140005e89", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x140005e8d", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a1c5]" + }, + { + "address": "0x140005e93", + "size": 7, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rbp + 0xe8]" + }, + { + "address": "0x140005e9a", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rbp + 0x4d8]" + }, + { + "address": "0x140005ea1", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140005ea4", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x140005ea7", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a1b3]" + }, + { + "address": "0x140005ead", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140005eb0", + "size": 2, + "mnemonic": "je", + "operands": "0x140005ef1" + } + ], + "successors": [ + "0x140005ef1", + "0x140005eb2" + ] + }, + { + "address": "0x140005e6a", + "size": 17, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005e6a", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x140005e6c", + "size": 2, + "mnemonic": "int", + "operands": "0x29" + }, + { + "address": "0x140005e6e", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 3" + }, + { + "address": "0x140005e73", + "size": 5, + "mnemonic": "call", + "operands": "0x140005e38" + }, + { + "address": "0x140005e78", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140005e7a", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x140005e7e", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x4d0" + }, + { + "address": "0x140005e84", + "size": 5, + "mnemonic": "call", + "operands": "0x14001ea80" + }, + { + "address": "0x140005e89", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x140005e8d", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a1c5]" + }, + { + "address": "0x140005e93", + "size": 7, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rbp + 0xe8]" + }, + { + "address": "0x140005e9a", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rbp + 0x4d8]" + }, + { + "address": "0x140005ea1", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140005ea4", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x140005ea7", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a1b3]" + }, + { + "address": "0x140005ead", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140005eb0", + "size": 2, + "mnemonic": "je", + "operands": "0x140005ef1" + } + ], + "successors": [ + "0x140005ef1", + "0x140005eb2" + ] + }, + { + "address": "0x140005ef1", + "size": 27, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005ef1", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x4c8]" + }, + { + "address": "0x140005ef8", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x50]" + }, + { + "address": "0x140005efd", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0xe8], rax" + }, + { + "address": "0x140005f04", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140005f06", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x4c8]" + }, + { + "address": "0x140005f0d", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x98" + }, + { + "address": "0x140005f13", + "size": 4, + "mnemonic": "add", + "operands": "rax, 8" + }, + { + "address": "0x140005f17", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x88], rax" + }, + { + "address": "0x140005f1e", + "size": 5, + "mnemonic": "call", + "operands": "0x14001ea80" + }, + { + "address": "0x140005f23", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x4c8]" + }, + { + "address": "0x140005f2a", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x60], rax" + }, + { + "address": "0x140005f2f", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x50], 0x40000015" + }, + { + "address": "0x140005f37", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x54], 1" + }, + { + "address": "0x140005f3f", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a17b]" + }, + { + "address": "0x140005f45", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, eax" + }, + { + "address": "0x140005f47", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x140005f49", + "size": 5, + "mnemonic": "lea", + "operands": "rax, [rsp + 0x50]" + }, + { + "address": "0x140005f4e", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x40], rax" + }, + { + "address": "0x140005f53", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp - 0x10]" + }, + { + "address": "0x140005f57", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x48], rax" + }, + { + "address": "0x140005f5c", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a116]" + }, + { + "address": "0x140005f62", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x40]" + }, + { + "address": "0x140005f67", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a103]" + }, + { + "address": "0x140005f6d", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140005f6f", + "size": 2, + "mnemonic": "jne", + "operands": "0x140005f7e" + }, + { + "address": "0x140005f71", + "size": 3, + "mnemonic": "cmp", + "operands": "ebx, 1" + }, + { + "address": "0x140005f74", + "size": 2, + "mnemonic": "je", + "operands": "0x140005f7e" + } + ], + "successors": [ + "0x140005f7e", + "0x140005f76" + ] + }, + { + "address": "0x140005eb2", + "size": 39, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005eb2", + "size": 7, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rbp + 0x4d8]" + }, + { + "address": "0x140005eb9", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x4e0]" + }, + { + "address": "0x140005ec0", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], 0" + }, + { + "address": "0x140005ec9", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rax" + }, + { + "address": "0x140005ecc", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rcx" + }, + { + "address": "0x140005ed1", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rbx" + }, + { + "address": "0x140005ed4", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x4e8]" + }, + { + "address": "0x140005edb", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rcx" + }, + { + "address": "0x140005ee0", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x140005ee4", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rcx" + }, + { + "address": "0x140005ee9", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x140005eeb", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a177]" + }, + { + "address": "0x140005ef1", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x4c8]" + }, + { + "address": "0x140005ef8", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x50]" + }, + { + "address": "0x140005efd", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0xe8], rax" + }, + { + "address": "0x140005f04", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140005f06", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x4c8]" + }, + { + "address": "0x140005f0d", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x98" + }, + { + "address": "0x140005f13", + "size": 4, + "mnemonic": "add", + "operands": "rax, 8" + }, + { + "address": "0x140005f17", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x88], rax" + }, + { + "address": "0x140005f1e", + "size": 5, + "mnemonic": "call", + "operands": "0x14001ea80" + }, + { + "address": "0x140005f23", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x4c8]" + }, + { + "address": "0x140005f2a", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x60], rax" + }, + { + "address": "0x140005f2f", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x50], 0x40000015" + }, + { + "address": "0x140005f37", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x54], 1" + }, + { + "address": "0x140005f3f", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a17b]" + }, + { + "address": "0x140005f45", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, eax" + }, + { + "address": "0x140005f47", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x140005f49", + "size": 5, + "mnemonic": "lea", + "operands": "rax, [rsp + 0x50]" + }, + { + "address": "0x140005f4e", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x40], rax" + }, + { + "address": "0x140005f53", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp - 0x10]" + }, + { + "address": "0x140005f57", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x48], rax" + }, + { + "address": "0x140005f5c", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a116]" + }, + { + "address": "0x140005f62", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x40]" + }, + { + "address": "0x140005f67", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a103]" + }, + { + "address": "0x140005f6d", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140005f6f", + "size": 2, + "mnemonic": "jne", + "operands": "0x140005f7e" + }, + { + "address": "0x140005f71", + "size": 3, + "mnemonic": "cmp", + "operands": "ebx, 1" + }, + { + "address": "0x140005f74", + "size": 2, + "mnemonic": "je", + "operands": "0x140005f7e" + } + ], + "successors": [ + "0x140005f7e", + "0x140005f76" + ] + }, + { + "address": "0x140005f7e", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140005f7e", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x5d0]" + }, + { + "address": "0x140005f86", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0x5c0" + }, + { + "address": "0x140005f8d", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140005f8e", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140005f76", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140005f76", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rax + 3]" + }, + { + "address": "0x140005f79", + "size": 5, + "mnemonic": "call", + "operands": "0x140005e38" + }, + { + "address": "0x140005f7e", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x5d0]" + }, + { + "address": "0x140005f86", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0x5c0" + }, + { + "address": "0x140005f8d", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140005f8e", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140005f98", + "name": "", + "blocks": [ + { + "address": "0x140005f98", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005f98", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x140005f9c", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x140005f9e", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a12c]" + }, + { + "address": "0x140005fa4", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140005fa7", + "size": 2, + "mnemonic": "je", + "operands": "0x140005fe3" + } + ], + "successors": [ + "0x140005fe3", + "0x140005fa9" + ] + }, + { + "address": "0x140005fe3", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140005fe3", + "size": 2, + "mnemonic": "xor", + "operands": "al, al" + }, + { + "address": "0x140005fe5", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x140005fe9", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140005fa9", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005fa9", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0x5a4d" + }, + { + "address": "0x140005fae", + "size": 3, + "mnemonic": "cmp", + "operands": "word ptr [rax], cx" + }, + { + "address": "0x140005fb1", + "size": 2, + "mnemonic": "jne", + "operands": "0x140005fe3" + }, + { + "address": "0x140005fb3", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax + 0x3c]" + }, + { + "address": "0x140005fb7", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rcx + rax], 0x4550" + }, + { + "address": "0x140005fbe", + "size": 2, + "mnemonic": "jne", + "operands": "0x140005fe3" + }, + { + "address": "0x140005fc0", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0x20b" + }, + { + "address": "0x140005fc5", + "size": 5, + "mnemonic": "cmp", + "operands": "word ptr [rcx + rax + 0x18], dx" + }, + { + "address": "0x140005fca", + "size": 2, + "mnemonic": "jne", + "operands": "0x140005fe3" + }, + { + "address": "0x140005fcc", + "size": 8, + "mnemonic": "cmp", + "operands": "dword ptr [rcx + rax + 0x84], 0xe" + }, + { + "address": "0x140005fd4", + "size": 2, + "mnemonic": "jbe", + "operands": "0x140005fe3" + }, + { + "address": "0x140005fd6", + "size": 8, + "mnemonic": "cmp", + "operands": "dword ptr [rcx + rax + 0xf8], 0" + }, + { + "address": "0x140005fde", + "size": 3, + "mnemonic": "setne", + "operands": "al" + }, + { + "address": "0x140005fe1", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140005fe5" + } + ], + "successors": [ + "0x140005fe5" + ] + }, + { + "address": "0x140005fe5", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140005fe5", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x140005fe9", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000e868", + "name": "", + "blocks": [ + { + "address": "0x14000e868", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000e868", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000e86c", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x2492d]" + }, + { + "address": "0x14000e873", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000e876", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000e8b1" + }, + { + "address": "0x14000e878", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x24909]" + }, + { + "address": "0x14000e87f", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000e882", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000e8aa" + }, + { + "address": "0x14000e884", + "size": 7, + "mnemonic": "cmp", + "operands": "qword ptr [rip + 0x24905], rax" + }, + { + "address": "0x14000e88b", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000e891" + }, + { + "address": "0x14000e88d", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000e88f", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000e8aa" + } + ], + "successors": [ + "0x14000e8aa" + ] + }, + { + "address": "0x14000e8aa", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000e8aa", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x248ef], rax" + }, + { + "address": "0x14000e8b1", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000e8b5", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000e8c0", + "name": "", + "blocks": [ + { + "address": "0x14000e8c0", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000e8c0", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, rdx" + }, + { + "address": "0x14000e8c3", + "size": 2, + "mnemonic": "je", + "operands": "0x14000e8f5" + } + ], + "successors": [ + "0x14000e8f5", + "0x14000e8c5" + ] + }, + { + "address": "0x14000e8f5", + "size": 1, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000e8f5", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000e8c5", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000e8c5", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000e8ca", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000e8cb", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000e8cf", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x14000e8d2", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14000e8d5", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx]" + }, + { + "address": "0x14000e8d8", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000e8db", + "size": 2, + "mnemonic": "je", + "operands": "0x14000e8e2" + } + ], + "successors": [ + "0x14000e8e2", + "0x14000e8dd" + ] + }, + { + "address": "0x14000e8e2", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000e8e2", + "size": 4, + "mnemonic": "add", + "operands": "rbx, 8" + }, + { + "address": "0x14000e8e6", + "size": 3, + "mnemonic": "cmp", + "operands": "rbx, rdi" + }, + { + "address": "0x14000e8e9", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000e8d5" + }, + { + "address": "0x14000e8eb", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000e8f0", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000e8f4", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000e8f5", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000e8dd", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000e8dd", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3a0" + }, + { + "address": "0x14000e8e2", + "size": 4, + "mnemonic": "add", + "operands": "rbx, 8" + }, + { + "address": "0x14000e8e6", + "size": 3, + "mnemonic": "cmp", + "operands": "rbx, rdi" + }, + { + "address": "0x14000e8e9", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000e8d5" + }, + { + "address": "0x14000e8eb", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000e8f0", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000e8f4", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000e8f5", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000e8f8", + "name": "", + "blocks": [ + { + "address": "0x14000e8f8", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000e8f8", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000e8fd", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000e8fe", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000e902", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x14000e905", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14000e908", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, rdx" + }, + { + "address": "0x14000e90b", + "size": 2, + "mnemonic": "je", + "operands": "0x14000e927" + } + ], + "successors": [ + "0x14000e927", + "0x14000e90d" + ] + }, + { + "address": "0x14000e927", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000e927", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000e929", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000e92e", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000e932", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000e933", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000e90d", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000e90d", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx]" + }, + { + "address": "0x14000e910", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000e913", + "size": 2, + "mnemonic": "je", + "operands": "0x14000e91e" + } + ], + "successors": [ + "0x14000e91e", + "0x14000e915" + ] + }, + { + "address": "0x14000e91e", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000e91e", + "size": 4, + "mnemonic": "add", + "operands": "rbx, 8" + }, + { + "address": "0x14000e922", + "size": 3, + "mnemonic": "cmp", + "operands": "rbx, rdi" + }, + { + "address": "0x14000e925", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000e90d" + }, + { + "address": "0x14000e927", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000e929", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000e92e", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000e932", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000e933", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000e915", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000e915", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3a0" + }, + { + "address": "0x14000e91a", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000e91c", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000e929" + }, + { + "address": "0x14000e91e", + "size": 4, + "mnemonic": "add", + "operands": "rbx, 8" + }, + { + "address": "0x14000e922", + "size": 3, + "mnemonic": "cmp", + "operands": "rbx, rdi" + }, + { + "address": "0x14000e925", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000e90d" + }, + { + "address": "0x14000e927", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000e929", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000e92e", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000e932", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000e933", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000ebbc", + "name": "", + "blocks": [ + { + "address": "0x14000ebbc", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ebbc", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000ebbe", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14000ebc0", + "size": 4, + "mnemonic": "lea", + "operands": "r8d, [rdx + 1]" + }, + { + "address": "0x14000ebc4", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000ea2c" + } + ], + "successors": [ + "0x14000ea2c" + ] + }, + { + "address": "0x14000ea2c", + "size": 14, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ea2c", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x18], r8d" + }, + { + "address": "0x14000ea31", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x10], edx" + }, + { + "address": "0x14000ea35", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000ea36", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14000ea39", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x50" + }, + { + "address": "0x14000ea3d", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x20], 0xfffffffffffffffe" + }, + { + "address": "0x14000ea45", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x60], rbx" + }, + { + "address": "0x14000ea4a", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, ecx" + }, + { + "address": "0x14000ea4c", + "size": 3, + "mnemonic": "test", + "operands": "r8d, r8d" + }, + { + "address": "0x14000ea4f", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000ea9b" + }, + { + "address": "0x14000ea51", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14000ea53", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x11677]" + }, + { + "address": "0x14000ea59", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000ea5c", + "size": 2, + "mnemonic": "je", + "operands": "0x14000ea9b" + } + ], + "successors": [ + "0x14000ea9b", + "0x14000ea5e" + ] + }, + { + "address": "0x14000ea9b", + "size": 23, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ea9b", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp + 0x28], 0" + }, + { + "address": "0x14000ea9f", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x18]" + }, + { + "address": "0x14000eaa3", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x18], rax" + }, + { + "address": "0x14000eaa7", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x20]" + }, + { + "address": "0x14000eaab", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x10], rax" + }, + { + "address": "0x14000eaaf", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x28]" + }, + { + "address": "0x14000eab3", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 8], rax" + }, + { + "address": "0x14000eab7", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 2" + }, + { + "address": "0x14000eabc", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x2c], eax" + }, + { + "address": "0x14000eabf", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x28], eax" + }, + { + "address": "0x14000eac2", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp - 0x2c]" + }, + { + "address": "0x14000eac6", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbp - 0x18]" + }, + { + "address": "0x14000eaca", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x28]" + }, + { + "address": "0x14000eace", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x30]" + }, + { + "address": "0x14000ead2", + "size": 5, + "mnemonic": "call", + "operands": "0x14000e934" + }, + { + "address": "0x14000ead7", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14000ead8", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rbp + 0x20], 0" + }, + { + "address": "0x14000eadc", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000eafc" + }, + { + "address": "0x14000eade", + "size": 5, + "mnemonic": "call", + "operands": "0x1400191c0" + }, + { + "address": "0x14000eae3", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x14000eae6", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000eaec" + }, + { + "address": "0x14000eae8", + "size": 2, + "mnemonic": "xor", + "operands": "dl, dl" + }, + { + "address": "0x14000eaea", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000eaf6" + } + ], + "successors": [ + "0x14000eaf6" + ] + }, + { + "address": "0x14000ea5e", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ea5e", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0x5a4d" + }, + { + "address": "0x14000ea63", + "size": 3, + "mnemonic": "cmp", + "operands": "word ptr [rax], cx" + }, + { + "address": "0x14000ea66", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000ea9b" + }, + { + "address": "0x14000ea68", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax + 0x3c]" + }, + { + "address": "0x14000ea6c", + "size": 3, + "mnemonic": "add", + "operands": "rcx, rax" + }, + { + "address": "0x14000ea6f", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rcx], 0x4550" + }, + { + "address": "0x14000ea75", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000ea9b" + }, + { + "address": "0x14000ea77", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x20b" + }, + { + "address": "0x14000ea7c", + "size": 4, + "mnemonic": "cmp", + "operands": "word ptr [rcx + 0x18], ax" + }, + { + "address": "0x14000ea80", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000ea9b" + }, + { + "address": "0x14000ea82", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rcx + 0x84], 0xe" + }, + { + "address": "0x14000ea89", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14000ea9b" + }, + { + "address": "0x14000ea8b", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rcx + 0xf8], 0" + }, + { + "address": "0x14000ea92", + "size": 2, + "mnemonic": "je", + "operands": "0x14000ea9b" + } + ], + "successors": [ + "0x14000ea9b", + "0x14000ea94" + ] + }, + { + "address": "0x14000eaf6", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000eaf6", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rbp + 0x20], 0" + }, + { + "address": "0x14000eafa", + "size": 2, + "mnemonic": "je", + "operands": "0x14000eb07" + } + ], + "successors": [ + "0x14000eb07", + "0x14000eafc" + ] + }, + { + "address": "0x14000ea94", + "size": 25, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ea94", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x14000ea96", + "size": 5, + "mnemonic": "call", + "operands": "0x14000eb40" + }, + { + "address": "0x14000ea9b", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp + 0x28], 0" + }, + { + "address": "0x14000ea9f", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x18]" + }, + { + "address": "0x14000eaa3", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x18], rax" + }, + { + "address": "0x14000eaa7", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x20]" + }, + { + "address": "0x14000eaab", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x10], rax" + }, + { + "address": "0x14000eaaf", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x28]" + }, + { + "address": "0x14000eab3", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 8], rax" + }, + { + "address": "0x14000eab7", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 2" + }, + { + "address": "0x14000eabc", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x2c], eax" + }, + { + "address": "0x14000eabf", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x28], eax" + }, + { + "address": "0x14000eac2", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp - 0x2c]" + }, + { + "address": "0x14000eac6", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbp - 0x18]" + }, + { + "address": "0x14000eaca", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x28]" + }, + { + "address": "0x14000eace", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x30]" + }, + { + "address": "0x14000ead2", + "size": 5, + "mnemonic": "call", + "operands": "0x14000e934" + }, + { + "address": "0x14000ead7", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14000ead8", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rbp + 0x20], 0" + }, + { + "address": "0x14000eadc", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000eafc" + }, + { + "address": "0x14000eade", + "size": 5, + "mnemonic": "call", + "operands": "0x1400191c0" + }, + { + "address": "0x14000eae3", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x14000eae6", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000eaec" + }, + { + "address": "0x14000eae8", + "size": 2, + "mnemonic": "xor", + "operands": "dl, dl" + }, + { + "address": "0x14000eaea", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000eaf6" + } + ], + "successors": [ + "0x14000eaf6" + ] + }, + { + "address": "0x14000eb07", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000eb07", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x14000eb09", + "size": 5, + "mnemonic": "call", + "operands": "0x14000eb10" + }, + { + "address": "0x14000eb0e", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000eafc", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000eafc", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14000eb01", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x50" + }, + { + "address": "0x14000eb05", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000eb06", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000ebcc", + "name": "", + "blocks": [ + { + "address": "0x14000ebcc", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ebcc", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x14000ebcf", + "size": 4, + "mnemonic": "lea", + "operands": "edx, [r8 + 2]" + }, + { + "address": "0x14000ebd3", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000ea2c" + } + ], + "successors": [ + "0x14000ea2c" + ] + } + ] + }, + { + "address": "0x14000ebd8", + "name": "", + "blocks": [ + { + "address": "0x14000ebd8", + "size": 14, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000ebd8", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000ebdc", + "size": 7, + "mnemonic": "mov", + "operands": "r8, qword ptr [rip + 0x2245d]" + }, + { + "address": "0x14000ebe3", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rcx" + }, + { + "address": "0x14000ebe6", + "size": 7, + "mnemonic": "cmp", + "operands": "qword ptr [rip + 0x245c3], r8" + }, + { + "address": "0x14000ebed", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000ec0e" + }, + { + "address": "0x14000ebef", + "size": 3, + "mnemonic": "mov", + "operands": "eax, r8d" + }, + { + "address": "0x14000ebf2", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0x40" + }, + { + "address": "0x14000ebf7", + "size": 3, + "mnemonic": "and", + "operands": "eax, 0x3f" + }, + { + "address": "0x14000ebfa", + "size": 2, + "mnemonic": "sub", + "operands": "ecx, eax" + }, + { + "address": "0x14000ebfc", + "size": 3, + "mnemonic": "ror", + "operands": "rdx, cl" + }, + { + "address": "0x14000ebff", + "size": 3, + "mnemonic": "xor", + "operands": "rdx, r8" + }, + { + "address": "0x14000ec02", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x245a7], rdx" + }, + { + "address": "0x14000ec09", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000ec0d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000ec14", + "name": "", + "blocks": [ + { + "address": "0x14000ec14", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ec14", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x14000ec17", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000ec19", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000ea2c" + } + ], + "successors": [ + "0x14000ea2c" + ] + } + ] + }, + { + "address": "0x14000ec88", + "name": "", + "blocks": [ + { + "address": "0x14000ec88", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000ec88", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x24539]" + }, + { + "address": "0x14000ec8f", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000ec90", + "name": "", + "blocks": [ + { + "address": "0x14000ec90", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000ec90", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x24539]" + }, + { + "address": "0x14000ec97", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001e360", + "name": "", + "blocks": [ + { + "address": "0x14001e360", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e360", + "size": 2, + "mnemonic": "jmp", + "operands": "rax" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140001150", + "name": "", + "blocks": [ + { + "address": "0x140001150", + "size": 26, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001150", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbx" + }, + { + "address": "0x140001155", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rsi" + }, + { + "address": "0x14000115a", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rcx" + }, + { + "address": "0x14000115f", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140001160", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140001162", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140001164", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140001166", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140001168", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x70" + }, + { + "address": "0x14000116c", + "size": 3, + "mnemonic": "mov", + "operands": "r12, rdx" + }, + { + "address": "0x14000116f", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rcx" + }, + { + "address": "0x140001172", + "size": 3, + "mnemonic": "xor", + "operands": "r13d, r13d" + }, + { + "address": "0x140001175", + "size": 3, + "mnemonic": "mov", + "operands": "edi, r13d" + }, + { + "address": "0x140001178", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x20], r13d" + }, + { + "address": "0x14000117d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdx" + }, + { + "address": "0x140001180", + "size": 5, + "mnemonic": "call", + "operands": "0x14001ef10" + }, + { + "address": "0x140001185", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rax" + }, + { + "address": "0x140001188", + "size": 3, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsi]" + }, + { + "address": "0x14000118b", + "size": 4, + "mnemonic": "movsxd", + "operands": "r9, dword ptr [r8 + 4]" + }, + { + "address": "0x14000118f", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r9 + rsi + 0x28]" + }, + { + "address": "0x140001194", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x140001197", + "size": 2, + "mnemonic": "jle", + "operands": "0x1400011a3" + }, + { + "address": "0x140001199", + "size": 3, + "mnemonic": "cmp", + "operands": "rbx, rax" + }, + { + "address": "0x14000119c", + "size": 2, + "mnemonic": "jle", + "operands": "0x1400011a3" + }, + { + "address": "0x14000119e", + "size": 3, + "mnemonic": "sub", + "operands": "rbx, rax" + }, + { + "address": "0x1400011a1", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400011a6" + } + ], + "successors": [ + "0x1400011a6" + ] + }, + { + "address": "0x1400011a6", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400011a6", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rsi" + }, + { + "address": "0x1400011a9", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0xb0], rsi" + }, + { + "address": "0x1400011b1", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r9 + rsi + 0x48]" + }, + { + "address": "0x1400011b6", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x1400011b9", + "size": 2, + "mnemonic": "je", + "operands": "0x1400011c1" + } + ], + "successors": [ + "0x1400011c1", + "0x1400011bb" + ] + }, + { + "address": "0x1400011c1", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400011c1", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsi]" + }, + { + "address": "0x1400011c4", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax + 4]" + }, + { + "address": "0x1400011c8", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rcx + rsi + 0x10], edi" + }, + { + "address": "0x1400011cc", + "size": 6, + "mnemonic": "jne", + "operands": "0x140001342" + }, + { + "address": "0x1400011d2", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + rsi + 0x50]" + }, + { + "address": "0x1400011d7", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x1400011da", + "size": 2, + "mnemonic": "je", + "operands": "0x1400011f7" + } + ], + "successors": [ + "0x1400011f7", + "0x1400011dc" + ] + }, + { + "address": "0x1400011bb", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400011bb", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x1400011be", + "size": 3, + "mnemonic": "call", + "operands": "qword ptr [rax + 8]" + }, + { + "address": "0x1400011c1", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsi]" + }, + { + "address": "0x1400011c4", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax + 4]" + }, + { + "address": "0x1400011c8", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rcx + rsi + 0x10], edi" + }, + { + "address": "0x1400011cc", + "size": 6, + "mnemonic": "jne", + "operands": "0x140001342" + }, + { + "address": "0x1400011d2", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + rsi + 0x50]" + }, + { + "address": "0x1400011d7", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x1400011da", + "size": 2, + "mnemonic": "je", + "operands": "0x1400011f7" + } + ], + "successors": [ + "0x1400011f7", + "0x1400011dc" + ] + }, + { + "address": "0x1400011f7", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400011f7", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsi]" + }, + { + "address": "0x1400011fa", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax + 4]" + }, + { + "address": "0x1400011fe", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [rcx + rsi + 0x18]" + }, + { + "address": "0x140001202", + "size": 5, + "mnemonic": "and", + "operands": "eax, 0x1c0" + }, + { + "address": "0x140001207", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 0x40" + }, + { + "address": "0x14000120a", + "size": 2, + "mnemonic": "je", + "operands": "0x14000127d" + } + ], + "successors": [ + "0x14000127d", + "0x14000120c" + ] + }, + { + "address": "0x1400011dc", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400011dc", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, rsi" + }, + { + "address": "0x1400011df", + "size": 2, + "mnemonic": "je", + "operands": "0x1400011f7" + } + ], + "successors": [ + "0x1400011f7", + "0x1400011e1" + ] + }, + { + "address": "0x14000127d", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000127d", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsi]" + }, + { + "address": "0x140001280", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax + 4]" + }, + { + "address": "0x140001284", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + rsi + 0x48]" + }, + { + "address": "0x140001289", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x14000128c", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x14000128f", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r12" + }, + { + "address": "0x140001292", + "size": 3, + "mnemonic": "call", + "operands": "qword ptr [rax + 0x48]" + }, + { + "address": "0x140001295", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, r14" + }, + { + "address": "0x140001298", + "size": 2, + "mnemonic": "je", + "operands": "0x1400012a7" + } + ], + "successors": [ + "0x1400012a7", + "0x14000129a" + ] + }, + { + "address": "0x14000120c", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000120c", + "size": 4, + "mnemonic": "nop", + "operands": "dword ptr [rax]" + }, + { + "address": "0x140001210", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x140001213", + "size": 2, + "mnemonic": "jle", + "operands": "0x14000127d" + }, + { + "address": "0x140001215", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsi]" + }, + { + "address": "0x140001218", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax + 4]" + }, + { + "address": "0x14000121c", + "size": 6, + "mnemonic": "movzx", + "operands": "r8d, byte ptr [rcx + rsi + 0x58]" + }, + { + "address": "0x140001222", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + rsi + 0x48]" + }, + { + "address": "0x140001227", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0x40]" + }, + { + "address": "0x14000122b", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [rax], 0" + }, + { + "address": "0x14000122f", + "size": 2, + "mnemonic": "je", + "operands": "0x140001255" + } + ], + "successors": [ + "0x140001255", + "0x140001231" + ] + }, + { + "address": "0x1400011e1", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400011e1", + "size": 5, + "mnemonic": "call", + "operands": "0x140002000" + }, + { + "address": "0x1400011e6", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsi]" + }, + { + "address": "0x1400011e9", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax + 4]" + }, + { + "address": "0x1400011ed", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rcx + rsi + 0x10], edi" + }, + { + "address": "0x1400011f1", + "size": 6, + "mnemonic": "jne", + "operands": "0x140001342" + }, + { + "address": "0x1400011f7", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsi]" + }, + { + "address": "0x1400011fa", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax + 4]" + }, + { + "address": "0x1400011fe", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [rcx + rsi + 0x18]" + }, + { + "address": "0x140001202", + "size": 5, + "mnemonic": "and", + "operands": "eax, 0x1c0" + }, + { + "address": "0x140001207", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 0x40" + }, + { + "address": "0x14000120a", + "size": 2, + "mnemonic": "je", + "operands": "0x14000127d" + } + ], + "successors": [ + "0x14000127d", + "0x14000120c" + ] + }, + { + "address": "0x1400012a7", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400012a7", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x1400012aa", + "size": 2, + "mnemonic": "jle", + "operands": "0x140001311" + }, + { + "address": "0x1400012ac", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsi]" + }, + { + "address": "0x1400012af", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax + 4]" + }, + { + "address": "0x1400012b3", + "size": 6, + "mnemonic": "movzx", + "operands": "r8d, byte ptr [rcx + rsi + 0x58]" + }, + { + "address": "0x1400012b9", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + rsi + 0x48]" + }, + { + "address": "0x1400012be", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0x40]" + }, + { + "address": "0x1400012c2", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [rax], 0" + }, + { + "address": "0x1400012c6", + "size": 2, + "mnemonic": "je", + "operands": "0x1400012ec" + } + ], + "successors": [ + "0x1400012ec", + "0x1400012c8" + ] + }, + { + "address": "0x14000129a", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000129a", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 4" + }, + { + "address": "0x14000129f", + "size": 2, + "mnemonic": "mov", + "operands": "edi, edx" + }, + { + "address": "0x1400012a1", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x20], edx" + }, + { + "address": "0x1400012a5", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140001316" + } + ], + "successors": [ + "0x140001316" + ] + }, + { + "address": "0x140001255", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001255", + "size": 3, + "mnemonic": "mov", + "operands": "edx, r8d" + }, + { + "address": "0x140001258", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x14000125b", + "size": 3, + "mnemonic": "call", + "operands": "qword ptr [rax + 0x18]" + }, + { + "address": "0x14000125e", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, -1" + }, + { + "address": "0x140001261", + "size": 2, + "mnemonic": "jne", + "operands": "0x140001273" + }, + { + "address": "0x140001263", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 4" + }, + { + "address": "0x140001268", + "size": 2, + "mnemonic": "mov", + "operands": "edi, edx" + }, + { + "address": "0x14000126a", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x20], edx" + }, + { + "address": "0x14000126e", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140001316" + } + ], + "successors": [ + "0x140001316" + ] + }, + { + "address": "0x140001231", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001231", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rcx + 0x58]" + }, + { + "address": "0x140001235", + "size": 2, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx]" + }, + { + "address": "0x140001237", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140001239", + "size": 2, + "mnemonic": "jle", + "operands": "0x140001255" + }, + { + "address": "0x14000123b", + "size": 2, + "mnemonic": "dec", + "operands": "eax" + }, + { + "address": "0x14000123d", + "size": 2, + "mnemonic": "mov", + "operands": "dword ptr [rdx], eax" + }, + { + "address": "0x14000123f", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x40]" + }, + { + "address": "0x140001243", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rcx]" + }, + { + "address": "0x140001246", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rdx + 1]" + }, + { + "address": "0x14000124a", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rcx], rax" + }, + { + "address": "0x14000124d", + "size": 3, + "mnemonic": "mov", + "operands": "byte ptr [rdx], r8b" + }, + { + "address": "0x140001250", + "size": 3, + "mnemonic": "mov", + "operands": "eax, r8d" + }, + { + "address": "0x140001253", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000125e" + } + ], + "successors": [ + "0x14000125e" + ] + }, + { + "address": "0x1400012ec", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400012ec", + "size": 3, + "mnemonic": "mov", + "operands": "edx, r8d" + }, + { + "address": "0x1400012ef", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x1400012f2", + "size": 3, + "mnemonic": "call", + "operands": "qword ptr [rax + 0x18]" + }, + { + "address": "0x1400012f5", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, -1" + }, + { + "address": "0x1400012f8", + "size": 2, + "mnemonic": "jne", + "operands": "0x140001307" + }, + { + "address": "0x1400012fa", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 4" + }, + { + "address": "0x1400012ff", + "size": 2, + "mnemonic": "mov", + "operands": "edi, edx" + }, + { + "address": "0x140001301", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x20], edx" + }, + { + "address": "0x140001305", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140001316" + } + ], + "successors": [ + "0x140001316" + ] + }, + { + "address": "0x1400012c8", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400012c8", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rcx + 0x58]" + }, + { + "address": "0x1400012cc", + "size": 2, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx]" + }, + { + "address": "0x1400012ce", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x1400012d0", + "size": 2, + "mnemonic": "jle", + "operands": "0x1400012ec" + }, + { + "address": "0x1400012d2", + "size": 2, + "mnemonic": "dec", + "operands": "eax" + }, + { + "address": "0x1400012d4", + "size": 2, + "mnemonic": "mov", + "operands": "dword ptr [rdx], eax" + }, + { + "address": "0x1400012d6", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x40]" + }, + { + "address": "0x1400012da", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rcx]" + }, + { + "address": "0x1400012dd", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rdx + 1]" + }, + { + "address": "0x1400012e1", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rcx], rax" + }, + { + "address": "0x1400012e4", + "size": 3, + "mnemonic": "mov", + "operands": "byte ptr [rdx], r8b" + }, + { + "address": "0x1400012e7", + "size": 3, + "mnemonic": "mov", + "operands": "eax, r8d" + }, + { + "address": "0x1400012ea", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400012f5" + } + ], + "successors": [ + "0x1400012f5" + ] + }, + { + "address": "0x140001316", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001316", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsi]" + }, + { + "address": "0x140001319", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax + 4]" + }, + { + "address": "0x14000131d", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rcx + rsi + 0x28], r13" + }, + { + "address": "0x140001322", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140001349" + } + ], + "successors": [ + "0x140001349" + ] + }, + { + "address": "0x14000125e", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000125e", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, -1" + }, + { + "address": "0x140001261", + "size": 2, + "mnemonic": "jne", + "operands": "0x140001273" + }, + { + "address": "0x140001263", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 4" + }, + { + "address": "0x140001268", + "size": 2, + "mnemonic": "mov", + "operands": "edi, edx" + }, + { + "address": "0x14000126a", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x20], edx" + }, + { + "address": "0x14000126e", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140001316" + } + ], + "successors": [ + "0x140001316" + ] + }, + { + "address": "0x1400012f5", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400012f5", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, -1" + }, + { + "address": "0x1400012f8", + "size": 2, + "mnemonic": "jne", + "operands": "0x140001307" + }, + { + "address": "0x1400012fa", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 4" + }, + { + "address": "0x1400012ff", + "size": 2, + "mnemonic": "mov", + "operands": "edi, edx" + }, + { + "address": "0x140001301", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x20], edx" + }, + { + "address": "0x140001305", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140001316" + } + ], + "successors": [ + "0x140001316" + ] + }, + { + "address": "0x140001349", + "size": 20, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001349", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsi]" + }, + { + "address": "0x14000134c", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax + 4]" + }, + { + "address": "0x140001350", + "size": 6, + "mnemonic": "cmp", + "operands": "qword ptr [rcx + rsi + 0x48], 0" + }, + { + "address": "0x140001356", + "size": 4, + "mnemonic": "cmovne", + "operands": "edx, r13d" + }, + { + "address": "0x14000135a", + "size": 2, + "mnemonic": "or", + "operands": "edx, edi" + }, + { + "address": "0x14000135c", + "size": 4, + "mnemonic": "or", + "operands": "edx, dword ptr [rcx + rsi + 0x10]" + }, + { + "address": "0x140001360", + "size": 3, + "mnemonic": "and", + "operands": "edx, 0x17" + }, + { + "address": "0x140001363", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rcx + rsi + 0x10], edx" + }, + { + "address": "0x140001367", + "size": 4, + "mnemonic": "and", + "operands": "edx, dword ptr [rcx + rsi + 0x14]" + }, + { + "address": "0x14000136b", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400013b2" + }, + { + "address": "0x14000136d", + "size": 5, + "mnemonic": "call", + "operands": "0x1400023f4" + }, + { + "address": "0x140001372", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x140001374", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000137e" + }, + { + "address": "0x140001376", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r15" + }, + { + "address": "0x140001379", + "size": 5, + "mnemonic": "call", + "operands": "0x140001d10" + }, + { + "address": "0x14000137e", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [r15]" + }, + { + "address": "0x140001381", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax + 4]" + }, + { + "address": "0x140001385", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + r15 + 0x48]" + }, + { + "address": "0x14000138a", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14000138d", + "size": 2, + "mnemonic": "je", + "operands": "0x140001395" + } + ], + "successors": [ + "0x140001395", + "0x14000138f" + ] + }, + { + "address": "0x140001395", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140001395", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsi" + }, + { + "address": "0x140001398", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x70]" + }, + { + "address": "0x14000139d", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x38]" + }, + { + "address": "0x1400013a1", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x48]" + }, + { + "address": "0x1400013a5", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x1400013a8", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x1400013aa", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x1400013ac", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x1400013ae", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x1400013b0", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400013b1", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000138f", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000138f", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x140001392", + "size": 3, + "mnemonic": "call", + "operands": "qword ptr [rax + 0x10]" + }, + { + "address": "0x140001395", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsi" + }, + { + "address": "0x140001398", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x70]" + }, + { + "address": "0x14000139d", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x38]" + }, + { + "address": "0x1400013a1", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x48]" + }, + { + "address": "0x1400013a5", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x1400013a8", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x1400013aa", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x1400013ac", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x1400013ae", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x1400013b0", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400013b1", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140001595", + "name": "", + "blocks": [ + { + "address": "0x140001595", + "size": 24, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001595", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140001596", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140001597", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140001598", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000159a", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14000159c", + "size": 5, + "mnemonic": "lea", + "operands": "rbp, [rsp - 0x37]" + }, + { + "address": "0x1400015a1", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0xa0" + }, + { + "address": "0x1400015a8", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x2fa91]" + }, + { + "address": "0x1400015af", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x1400015b2", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x27], rax" + }, + { + "address": "0x1400015b6", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [r8 + 0x18], 0xf" + }, + { + "address": "0x1400015bb", + "size": 3, + "mnemonic": "xorps", + "operands": "xmm0, xmm0" + }, + { + "address": "0x1400015be", + "size": 3, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rdx]" + }, + { + "address": "0x1400015c1", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rdx" + }, + { + "address": "0x1400015c4", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rcx" + }, + { + "address": "0x1400015c7", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rbp - 0x39], xmm0" + }, + { + "address": "0x1400015cb", + "size": 3, + "mnemonic": "mov", + "operands": "r14, r8" + }, + { + "address": "0x1400015ce", + "size": 4, + "mnemonic": "movaps", + "operands": "xmmword ptr [rbp - 0x19], xmm1" + }, + { + "address": "0x1400015d2", + "size": 2, + "mnemonic": "jbe", + "operands": "0x1400015d7" + }, + { + "address": "0x1400015d4", + "size": 3, + "mnemonic": "mov", + "operands": "r14, qword ptr [r8]" + }, + { + "address": "0x1400015d7", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r8 + 0x10]" + }, + { + "address": "0x1400015db", + "size": 10, + "mnemonic": "movabs", + "operands": "rdi, 0x7fffffffffffffff" + }, + { + "address": "0x1400015e5", + "size": 3, + "mnemonic": "cmp", + "operands": "rbx, rdi" + }, + { + "address": "0x1400015e8", + "size": 6, + "mnemonic": "ja", + "operands": "0x1400017bd" + } + ], + "successors": [ + "0x1400017bd", + "0x1400015ee" + ] + }, + { + "address": "0x1400017bd", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400017bd", + "size": 5, + "mnemonic": "call", + "operands": "0x140001df0" + }, + { + "address": "0x1400017c2", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400015ee", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400015ee", + "size": 4, + "mnemonic": "cmp", + "operands": "rbx, 0xf" + }, + { + "address": "0x1400015f2", + "size": 2, + "mnemonic": "ja", + "operands": "0x14000160f" + } + ], + "successors": [ + "0x14000160f", + "0x1400015f4" + ] + }, + { + "address": "0x14000160f", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000160f", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140001612", + "size": 4, + "mnemonic": "or", + "operands": "rax, 0xf" + }, + { + "address": "0x140001616", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, rdi" + }, + { + "address": "0x140001619", + "size": 2, + "mnemonic": "ja", + "operands": "0x14000162a" + } + ], + "successors": [ + "0x14000162a", + "0x14000161b" + ] + }, + { + "address": "0x1400015f4", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400015f4", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x29], rbx" + }, + { + "address": "0x1400015f8", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x21], 0xf" + }, + { + "address": "0x140001600", + "size": 4, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [r14]" + }, + { + "address": "0x140001604", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rbp - 0x39], xmm0" + }, + { + "address": "0x140001608", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x14000160b", + "size": 2, + "mnemonic": "je", + "operands": "0x140001668" + } + ], + "successors": [ + "0x140001668", + "0x14000160d" + ] + }, + { + "address": "0x14000162a", + "size": 35, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000162a", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rdi + 1]" + }, + { + "address": "0x14000162e", + "size": 5, + "mnemonic": "call", + "operands": "0x140001410" + }, + { + "address": "0x140001633", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbx + 1]" + }, + { + "address": "0x140001637", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x39], rax" + }, + { + "address": "0x14000163b", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r14" + }, + { + "address": "0x14000163e", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x29], rbx" + }, + { + "address": "0x140001642", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x140001645", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x21], rdi" + }, + { + "address": "0x140001649", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3e0" + }, + { + "address": "0x14000164e", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 2" + }, + { + "address": "0x140001654", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x1ee3d]" + }, + { + "address": "0x14000165b", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x39]" + }, + { + "address": "0x14000165f", + "size": 5, + "mnemonic": "call", + "operands": "0x140001e10" + }, + { + "address": "0x140001664", + "size": 4, + "mnemonic": "movaps", + "operands": "xmm1, xmmword ptr [rbp - 0x19]" + }, + { + "address": "0x140001668", + "size": 4, + "mnemonic": "movdqa", + "operands": "xmm0, xmm1" + }, + { + "address": "0x14000166c", + "size": 5, + "mnemonic": "movd", + "operands": "r8d, xmm1" + }, + { + "address": "0x140001671", + "size": 5, + "mnemonic": "psrldq", + "operands": "xmm0, 8" + }, + { + "address": "0x140001676", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x19]" + }, + { + "address": "0x14000167a", + "size": 5, + "mnemonic": "movq", + "operands": "rcx, xmm0" + }, + { + "address": "0x14000167f", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x140001682", + "size": 3, + "mnemonic": "call", + "operands": "qword ptr [rax + 0x10]" + }, + { + "address": "0x140001685", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rbp - 1], 0xf" + }, + { + "address": "0x14000168a", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x19]" + }, + { + "address": "0x14000168e", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [rbp - 9]" + }, + { + "address": "0x140001692", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x39]" + }, + { + "address": "0x140001696", + "size": 5, + "mnemonic": "cmova", + "operands": "rdx, qword ptr [rbp - 0x19]" + }, + { + "address": "0x14000169b", + "size": 5, + "mnemonic": "call", + "operands": "0x140001e10" + }, + { + "address": "0x1400016a0", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rbp - 1]" + }, + { + "address": "0x1400016a4", + "size": 4, + "mnemonic": "cmp", + "operands": "rdx, 0xf" + }, + { + "address": "0x1400016a8", + "size": 2, + "mnemonic": "jbe", + "operands": "0x1400016db" + }, + { + "address": "0x1400016aa", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x19]" + }, + { + "address": "0x1400016ae", + "size": 3, + "mnemonic": "inc", + "operands": "rdx" + }, + { + "address": "0x1400016b1", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rcx" + }, + { + "address": "0x1400016b4", + "size": 7, + "mnemonic": "cmp", + "operands": "rdx, 0x1000" + }, + { + "address": "0x1400016bb", + "size": 2, + "mnemonic": "jb", + "operands": "0x1400016d6" + } + ], + "successors": [ + "0x1400016d6", + "0x1400016bd" + ] + }, + { + "address": "0x14000161b", + "size": 39, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000161b", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0x16" + }, + { + "address": "0x140001620", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rax" + }, + { + "address": "0x140001623", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, rcx" + }, + { + "address": "0x140001626", + "size": 4, + "mnemonic": "cmovb", + "operands": "rdi, rcx" + }, + { + "address": "0x14000162a", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rdi + 1]" + }, + { + "address": "0x14000162e", + "size": 5, + "mnemonic": "call", + "operands": "0x140001410" + }, + { + "address": "0x140001633", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbx + 1]" + }, + { + "address": "0x140001637", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x39], rax" + }, + { + "address": "0x14000163b", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r14" + }, + { + "address": "0x14000163e", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x29], rbx" + }, + { + "address": "0x140001642", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x140001645", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x21], rdi" + }, + { + "address": "0x140001649", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3e0" + }, + { + "address": "0x14000164e", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 2" + }, + { + "address": "0x140001654", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x1ee3d]" + }, + { + "address": "0x14000165b", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x39]" + }, + { + "address": "0x14000165f", + "size": 5, + "mnemonic": "call", + "operands": "0x140001e10" + }, + { + "address": "0x140001664", + "size": 4, + "mnemonic": "movaps", + "operands": "xmm1, xmmword ptr [rbp - 0x19]" + }, + { + "address": "0x140001668", + "size": 4, + "mnemonic": "movdqa", + "operands": "xmm0, xmm1" + }, + { + "address": "0x14000166c", + "size": 5, + "mnemonic": "movd", + "operands": "r8d, xmm1" + }, + { + "address": "0x140001671", + "size": 5, + "mnemonic": "psrldq", + "operands": "xmm0, 8" + }, + { + "address": "0x140001676", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x19]" + }, + { + "address": "0x14000167a", + "size": 5, + "mnemonic": "movq", + "operands": "rcx, xmm0" + }, + { + "address": "0x14000167f", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x140001682", + "size": 3, + "mnemonic": "call", + "operands": "qword ptr [rax + 0x10]" + }, + { + "address": "0x140001685", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rbp - 1], 0xf" + }, + { + "address": "0x14000168a", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x19]" + }, + { + "address": "0x14000168e", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [rbp - 9]" + }, + { + "address": "0x140001692", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x39]" + }, + { + "address": "0x140001696", + "size": 5, + "mnemonic": "cmova", + "operands": "rdx, qword ptr [rbp - 0x19]" + }, + { + "address": "0x14000169b", + "size": 5, + "mnemonic": "call", + "operands": "0x140001e10" + }, + { + "address": "0x1400016a0", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rbp - 1]" + }, + { + "address": "0x1400016a4", + "size": 4, + "mnemonic": "cmp", + "operands": "rdx, 0xf" + }, + { + "address": "0x1400016a8", + "size": 2, + "mnemonic": "jbe", + "operands": "0x1400016db" + }, + { + "address": "0x1400016aa", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x19]" + }, + { + "address": "0x1400016ae", + "size": 3, + "mnemonic": "inc", + "operands": "rdx" + }, + { + "address": "0x1400016b1", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rcx" + }, + { + "address": "0x1400016b4", + "size": 7, + "mnemonic": "cmp", + "operands": "rdx, 0x1000" + }, + { + "address": "0x1400016bb", + "size": 2, + "mnemonic": "jb", + "operands": "0x1400016d6" + } + ], + "successors": [ + "0x1400016d6", + "0x1400016bd" + ] + }, + { + "address": "0x140001668", + "size": 21, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001668", + "size": 4, + "mnemonic": "movdqa", + "operands": "xmm0, xmm1" + }, + { + "address": "0x14000166c", + "size": 5, + "mnemonic": "movd", + "operands": "r8d, xmm1" + }, + { + "address": "0x140001671", + "size": 5, + "mnemonic": "psrldq", + "operands": "xmm0, 8" + }, + { + "address": "0x140001676", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x19]" + }, + { + "address": "0x14000167a", + "size": 5, + "mnemonic": "movq", + "operands": "rcx, xmm0" + }, + { + "address": "0x14000167f", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x140001682", + "size": 3, + "mnemonic": "call", + "operands": "qword ptr [rax + 0x10]" + }, + { + "address": "0x140001685", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rbp - 1], 0xf" + }, + { + "address": "0x14000168a", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x19]" + }, + { + "address": "0x14000168e", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [rbp - 9]" + }, + { + "address": "0x140001692", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x39]" + }, + { + "address": "0x140001696", + "size": 5, + "mnemonic": "cmova", + "operands": "rdx, qword ptr [rbp - 0x19]" + }, + { + "address": "0x14000169b", + "size": 5, + "mnemonic": "call", + "operands": "0x140001e10" + }, + { + "address": "0x1400016a0", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rbp - 1]" + }, + { + "address": "0x1400016a4", + "size": 4, + "mnemonic": "cmp", + "operands": "rdx, 0xf" + }, + { + "address": "0x1400016a8", + "size": 2, + "mnemonic": "jbe", + "operands": "0x1400016db" + }, + { + "address": "0x1400016aa", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x19]" + }, + { + "address": "0x1400016ae", + "size": 3, + "mnemonic": "inc", + "operands": "rdx" + }, + { + "address": "0x1400016b1", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rcx" + }, + { + "address": "0x1400016b4", + "size": 7, + "mnemonic": "cmp", + "operands": "rdx, 0x1000" + }, + { + "address": "0x1400016bb", + "size": 2, + "mnemonic": "jb", + "operands": "0x1400016d6" + } + ], + "successors": [ + "0x1400016d6", + "0x1400016bd" + ] + }, + { + "address": "0x14000160d", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000160d", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000164e" + } + ], + "successors": [ + "0x14000164e" + ] + }, + { + "address": "0x1400016d6", + "size": 30, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400016d6", + "size": 5, + "mnemonic": "call", + "operands": "0x140005170" + }, + { + "address": "0x1400016db", + "size": 4, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rbp - 0x39]" + }, + { + "address": "0x1400016df", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rsi + 8]" + }, + { + "address": "0x1400016e3", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x11], 1" + }, + { + "address": "0x1400016e7", + "size": 4, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rbp - 0x29]" + }, + { + "address": "0x1400016eb", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbp + 7]" + }, + { + "address": "0x1400016ef", + "size": 5, + "mnemonic": "movq", + "operands": "rcx, xmm0" + }, + { + "address": "0x1400016f4", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rbp + 0x17], xmm1" + }, + { + "address": "0x1400016f8", + "size": 5, + "mnemonic": "psrldq", + "operands": "xmm1, 8" + }, + { + "address": "0x1400016fd", + "size": 5, + "mnemonic": "movq", + "operands": "rax, xmm1" + }, + { + "address": "0x140001702", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, 0xf" + }, + { + "address": "0x140001706", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1ecdb]" + }, + { + "address": "0x14000170d", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rbp + 7], xmm0" + }, + { + "address": "0x140001711", + "size": 4, + "mnemonic": "cmova", + "operands": "r8, rcx" + }, + { + "address": "0x140001715", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rsi], rax" + }, + { + "address": "0x140001718", + "size": 3, + "mnemonic": "xorps", + "operands": "xmm0, xmm0" + }, + { + "address": "0x14000171b", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x19], r8" + }, + { + "address": "0x14000171f", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x19]" + }, + { + "address": "0x140001723", + "size": 3, + "mnemonic": "movups", + "operands": "xmmword ptr [rdx], xmm0" + }, + { + "address": "0x140001726", + "size": 5, + "mnemonic": "call", + "operands": "0x1400060f0" + }, + { + "address": "0x14000172b", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rbp + 0x1f]" + }, + { + "address": "0x14000172f", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1ed3a]" + }, + { + "address": "0x140001736", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rsi], rax" + }, + { + "address": "0x140001739", + "size": 4, + "mnemonic": "cmp", + "operands": "rdx, 0xf" + }, + { + "address": "0x14000173d", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14000176c" + }, + { + "address": "0x14000173f", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 7]" + }, + { + "address": "0x140001743", + "size": 3, + "mnemonic": "inc", + "operands": "rdx" + }, + { + "address": "0x140001746", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rcx" + }, + { + "address": "0x140001749", + "size": 7, + "mnemonic": "cmp", + "operands": "rdx, 0x1000" + }, + { + "address": "0x140001750", + "size": 2, + "mnemonic": "jb", + "operands": "0x140001767" + } + ], + "successors": [ + "0x140001767", + "0x140001752" + ] + }, + { + "address": "0x1400016bd", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400016bd", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx - 8]" + }, + { + "address": "0x1400016c1", + "size": 4, + "mnemonic": "add", + "operands": "rdx, 0x27" + }, + { + "address": "0x1400016c5", + "size": 3, + "mnemonic": "sub", + "operands": "rax, rcx" + }, + { + "address": "0x1400016c8", + "size": 4, + "mnemonic": "sub", + "operands": "rax, 8" + }, + { + "address": "0x1400016cc", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, 0x1f" + }, + { + "address": "0x1400016d0", + "size": 6, + "mnemonic": "ja", + "operands": "0x1400017c3" + } + ], + "successors": [ + "0x1400017c3", + "0x1400016d6" + ] + }, + { + "address": "0x14000164e", + "size": 26, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000164e", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 2" + }, + { + "address": "0x140001654", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x1ee3d]" + }, + { + "address": "0x14000165b", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x39]" + }, + { + "address": "0x14000165f", + "size": 5, + "mnemonic": "call", + "operands": "0x140001e10" + }, + { + "address": "0x140001664", + "size": 4, + "mnemonic": "movaps", + "operands": "xmm1, xmmword ptr [rbp - 0x19]" + }, + { + "address": "0x140001668", + "size": 4, + "mnemonic": "movdqa", + "operands": "xmm0, xmm1" + }, + { + "address": "0x14000166c", + "size": 5, + "mnemonic": "movd", + "operands": "r8d, xmm1" + }, + { + "address": "0x140001671", + "size": 5, + "mnemonic": "psrldq", + "operands": "xmm0, 8" + }, + { + "address": "0x140001676", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x19]" + }, + { + "address": "0x14000167a", + "size": 5, + "mnemonic": "movq", + "operands": "rcx, xmm0" + }, + { + "address": "0x14000167f", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x140001682", + "size": 3, + "mnemonic": "call", + "operands": "qword ptr [rax + 0x10]" + }, + { + "address": "0x140001685", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rbp - 1], 0xf" + }, + { + "address": "0x14000168a", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x19]" + }, + { + "address": "0x14000168e", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [rbp - 9]" + }, + { + "address": "0x140001692", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x39]" + }, + { + "address": "0x140001696", + "size": 5, + "mnemonic": "cmova", + "operands": "rdx, qword ptr [rbp - 0x19]" + }, + { + "address": "0x14000169b", + "size": 5, + "mnemonic": "call", + "operands": "0x140001e10" + }, + { + "address": "0x1400016a0", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rbp - 1]" + }, + { + "address": "0x1400016a4", + "size": 4, + "mnemonic": "cmp", + "operands": "rdx, 0xf" + }, + { + "address": "0x1400016a8", + "size": 2, + "mnemonic": "jbe", + "operands": "0x1400016db" + }, + { + "address": "0x1400016aa", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x19]" + }, + { + "address": "0x1400016ae", + "size": 3, + "mnemonic": "inc", + "operands": "rdx" + }, + { + "address": "0x1400016b1", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rcx" + }, + { + "address": "0x1400016b4", + "size": 7, + "mnemonic": "cmp", + "operands": "rdx, 0x1000" + }, + { + "address": "0x1400016bb", + "size": 2, + "mnemonic": "jb", + "operands": "0x1400016d6" + } + ], + "successors": [ + "0x1400016d6", + "0x1400016bd" + ] + }, + { + "address": "0x140001767", + "size": 17, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140001767", + "size": 5, + "mnemonic": "call", + "operands": "0x140005170" + }, + { + "address": "0x14000176c", + "size": 4, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [r15]" + }, + { + "address": "0x140001770", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1ed11]" + }, + { + "address": "0x140001777", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rsi], rax" + }, + { + "address": "0x14000177a", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsi" + }, + { + "address": "0x14000177d", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rsi + 0x18], xmm0" + }, + { + "address": "0x140001781", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x27]" + }, + { + "address": "0x140001785", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x140001788", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x14000178d", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0xe8]" + }, + { + "address": "0x140001795", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0xa0" + }, + { + "address": "0x14000179c", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000179e", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x1400017a0", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400017a1", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x1400017a2", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x1400017a3", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140001752", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001752", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx - 8]" + }, + { + "address": "0x140001756", + "size": 4, + "mnemonic": "add", + "operands": "rdx, 0x27" + }, + { + "address": "0x14000175a", + "size": 3, + "mnemonic": "sub", + "operands": "rax, rcx" + }, + { + "address": "0x14000175d", + "size": 4, + "mnemonic": "sub", + "operands": "rax, 8" + }, + { + "address": "0x140001761", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, 0x1f" + }, + { + "address": "0x140001765", + "size": 2, + "mnemonic": "ja", + "operands": "0x1400017a4" + } + ], + "successors": [ + "0x1400017a4", + "0x140001767" + ] + }, + { + "address": "0x1400017c3", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400017c3", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x1400017c6", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], 0" + }, + { + "address": "0x1400017cf", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x1400017d2", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x1400017d4", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x1400017d6", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afd4" + }, + { + "address": "0x1400017db", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400017a4", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400017a4", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x1400017a7", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], 0" + }, + { + "address": "0x1400017b0", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x1400017b3", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x1400017b5", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x1400017b7", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afd4" + }, + { + "address": "0x1400017bc", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140002616", + "name": "", + "blocks": [ + { + "address": "0x140002616", + "size": 37, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140002616", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140002617", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140002618", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140002619", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000261b", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000261f", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rcx" + }, + { + "address": "0x140002622", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140002624", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x58]" + }, + { + "address": "0x140002629", + "size": 5, + "mnemonic": "call", + "operands": "0x14000448c" + }, + { + "address": "0x14000262e", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14000262f", + "size": 7, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rip + 0x2fcc2]" + }, + { + "address": "0x140002636", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x60], rsi" + }, + { + "address": "0x14000263b", + "size": 7, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rip + 0x2fcae]" + }, + { + "address": "0x140002642", + "size": 3, + "mnemonic": "test", + "operands": "rdi, rdi" + }, + { + "address": "0x140002645", + "size": 2, + "mnemonic": "jne", + "operands": "0x140002684" + }, + { + "address": "0x140002647", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140002649", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x50]" + }, + { + "address": "0x14000264e", + "size": 5, + "mnemonic": "call", + "operands": "0x14000448c" + }, + { + "address": "0x140002653", + "size": 7, + "mnemonic": "cmp", + "operands": "qword ptr [rip + 0x2fc96], rdi" + }, + { + "address": "0x14000265a", + "size": 2, + "mnemonic": "jne", + "operands": "0x140002673" + }, + { + "address": "0x14000265c", + "size": 6, + "mnemonic": "mov", + "operands": "eax, dword ptr [rip + 0x2fdfe]" + }, + { + "address": "0x140002662", + "size": 2, + "mnemonic": "inc", + "operands": "eax" + }, + { + "address": "0x140002664", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2fdf6], eax" + }, + { + "address": "0x14000266a", + "size": 2, + "mnemonic": "cdqe", + "operands": "" + }, + { + "address": "0x14000266c", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x2fc7d], rax" + }, + { + "address": "0x140002673", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x50]" + }, + { + "address": "0x140002678", + "size": 5, + "mnemonic": "call", + "operands": "0x140004504" + }, + { + "address": "0x14000267d", + "size": 7, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rip + 0x2fc6c]" + }, + { + "address": "0x140002684", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 8]" + }, + { + "address": "0x140002688", + "size": 8, + "mnemonic": "lea", + "operands": "r14, [rdi*8]" + }, + { + "address": "0x140002690", + "size": 4, + "mnemonic": "cmp", + "operands": "rdi, qword ptr [rcx + 0x18]" + }, + { + "address": "0x140002694", + "size": 2, + "mnemonic": "jae", + "operands": "0x1400026a5" + }, + { + "address": "0x140002696", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0x10]" + }, + { + "address": "0x14000269a", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r14 + rax]" + }, + { + "address": "0x14000269e", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x1400026a1", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000270b" + }, + { + "address": "0x1400026a3", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400026a7" + } + ], + "successors": [ + "0x1400026a7" + ] + }, + { + "address": "0x1400026a7", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400026a7", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rcx + 0x24], 0" + }, + { + "address": "0x1400026ab", + "size": 2, + "mnemonic": "je", + "operands": "0x1400026c0" + } + ], + "successors": [ + "0x1400026c0", + "0x1400026ad" + ] + }, + { + "address": "0x1400026c0", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400026c0", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x1400026c3", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000270b" + }, + { + "address": "0x1400026c5", + "size": 3, + "mnemonic": "test", + "operands": "rsi, rsi" + }, + { + "address": "0x1400026c8", + "size": 2, + "mnemonic": "je", + "operands": "0x1400026cf" + } + ], + "successors": [ + "0x1400026cf", + "0x1400026ca" + ] + }, + { + "address": "0x1400026ad", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400026ad", + "size": 5, + "mnemonic": "call", + "operands": "0x140004650" + }, + { + "address": "0x1400026b2", + "size": 4, + "mnemonic": "cmp", + "operands": "rdi, qword ptr [rax + 0x18]" + }, + { + "address": "0x1400026b6", + "size": 2, + "mnemonic": "jae", + "operands": "0x1400026c5" + }, + { + "address": "0x1400026b8", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax + 0x10]" + }, + { + "address": "0x1400026bc", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r14 + rax]" + }, + { + "address": "0x1400026c0", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x1400026c3", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000270b" + }, + { + "address": "0x1400026c5", + "size": 3, + "mnemonic": "test", + "operands": "rsi, rsi" + }, + { + "address": "0x1400026c8", + "size": 2, + "mnemonic": "je", + "operands": "0x1400026cf" + } + ], + "successors": [ + "0x1400026cf", + "0x1400026ca" + ] + }, + { + "address": "0x1400026cf", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400026cf", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbp" + }, + { + "address": "0x1400026d2", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x60]" + }, + { + "address": "0x1400026d7", + "size": 5, + "mnemonic": "call", + "operands": "0x1400030cc" + }, + { + "address": "0x1400026dc", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, -1" + }, + { + "address": "0x1400026e0", + "size": 2, + "mnemonic": "je", + "operands": "0x140002723" + } + ], + "successors": [ + "0x140002723", + "0x1400026e2" + ] + }, + { + "address": "0x1400026ca", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400026ca", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rsi" + }, + { + "address": "0x1400026cd", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000270b" + } + ], + "successors": [ + "0x14000270b" + ] + }, + { + "address": "0x140002723", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140002723", + "size": 5, + "mnemonic": "call", + "operands": "0x14000348c" + }, + { + "address": "0x140002728", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140002729", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400026e2", + "size": 19, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400026e2", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x60]" + }, + { + "address": "0x1400026e7", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x50], rbx" + }, + { + "address": "0x1400026ec", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x1400026ef", + "size": 5, + "mnemonic": "call", + "operands": "0x140004614" + }, + { + "address": "0x1400026f4", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx]" + }, + { + "address": "0x1400026f7", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 8]" + }, + { + "address": "0x1400026fb", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x1400026fe", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1dbbc]" + }, + { + "address": "0x140002704", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x2fbed], rbx" + }, + { + "address": "0x14000270b", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x58]" + }, + { + "address": "0x140002710", + "size": 5, + "mnemonic": "call", + "operands": "0x140004504" + }, + { + "address": "0x140002715", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140002718", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000271c", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000271e", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000271f", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140002720", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140002721", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140002722", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000270b", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000270b", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x58]" + }, + { + "address": "0x140002710", + "size": 5, + "mnemonic": "call", + "operands": "0x140004504" + }, + { + "address": "0x140002715", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140002718", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000271c", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000271e", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000271f", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140002720", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140002721", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140002722", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000272e", + "name": "", + "blocks": [ + { + "address": "0x14000272e", + "size": 37, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000272e", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000272f", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140002730", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140002731", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140002733", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140002737", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rcx" + }, + { + "address": "0x14000273a", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000273c", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x58]" + }, + { + "address": "0x140002741", + "size": 5, + "mnemonic": "call", + "operands": "0x14000448c" + }, + { + "address": "0x140002746", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140002747", + "size": 7, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rip + 0x2fb9a]" + }, + { + "address": "0x14000274e", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x60], rsi" + }, + { + "address": "0x140002753", + "size": 7, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rip + 0x2fd1e]" + }, + { + "address": "0x14000275a", + "size": 3, + "mnemonic": "test", + "operands": "rdi, rdi" + }, + { + "address": "0x14000275d", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000279c" + }, + { + "address": "0x14000275f", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140002761", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x50]" + }, + { + "address": "0x140002766", + "size": 5, + "mnemonic": "call", + "operands": "0x14000448c" + }, + { + "address": "0x14000276b", + "size": 7, + "mnemonic": "cmp", + "operands": "qword ptr [rip + 0x2fd06], rdi" + }, + { + "address": "0x140002772", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000278b" + }, + { + "address": "0x140002774", + "size": 6, + "mnemonic": "mov", + "operands": "eax, dword ptr [rip + 0x2fce6]" + }, + { + "address": "0x14000277a", + "size": 2, + "mnemonic": "inc", + "operands": "eax" + }, + { + "address": "0x14000277c", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2fcde], eax" + }, + { + "address": "0x140002782", + "size": 2, + "mnemonic": "cdqe", + "operands": "" + }, + { + "address": "0x140002784", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x2fced], rax" + }, + { + "address": "0x14000278b", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x50]" + }, + { + "address": "0x140002790", + "size": 5, + "mnemonic": "call", + "operands": "0x140004504" + }, + { + "address": "0x140002795", + "size": 7, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rip + 0x2fcdc]" + }, + { + "address": "0x14000279c", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 8]" + }, + { + "address": "0x1400027a0", + "size": 8, + "mnemonic": "lea", + "operands": "r14, [rdi*8]" + }, + { + "address": "0x1400027a8", + "size": 4, + "mnemonic": "cmp", + "operands": "rdi, qword ptr [rcx + 0x18]" + }, + { + "address": "0x1400027ac", + "size": 2, + "mnemonic": "jae", + "operands": "0x1400027bd" + }, + { + "address": "0x1400027ae", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0x10]" + }, + { + "address": "0x1400027b2", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r14 + rax]" + }, + { + "address": "0x1400027b6", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x1400027b9", + "size": 2, + "mnemonic": "jne", + "operands": "0x140002823" + }, + { + "address": "0x1400027bb", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400027bf" + } + ], + "successors": [ + "0x1400027bf" + ] + }, + { + "address": "0x1400027bf", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400027bf", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rcx + 0x24], 0" + }, + { + "address": "0x1400027c3", + "size": 2, + "mnemonic": "je", + "operands": "0x1400027d8" + } + ], + "successors": [ + "0x1400027d8", + "0x1400027c5" + ] + }, + { + "address": "0x1400027d8", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400027d8", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x1400027db", + "size": 2, + "mnemonic": "jne", + "operands": "0x140002823" + }, + { + "address": "0x1400027dd", + "size": 3, + "mnemonic": "test", + "operands": "rsi, rsi" + }, + { + "address": "0x1400027e0", + "size": 2, + "mnemonic": "je", + "operands": "0x1400027e7" + } + ], + "successors": [ + "0x1400027e7", + "0x1400027e2" + ] + }, + { + "address": "0x1400027c5", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400027c5", + "size": 5, + "mnemonic": "call", + "operands": "0x140004650" + }, + { + "address": "0x1400027ca", + "size": 4, + "mnemonic": "cmp", + "operands": "rdi, qword ptr [rax + 0x18]" + }, + { + "address": "0x1400027ce", + "size": 2, + "mnemonic": "jae", + "operands": "0x1400027dd" + }, + { + "address": "0x1400027d0", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax + 0x10]" + }, + { + "address": "0x1400027d4", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r14 + rax]" + }, + { + "address": "0x1400027d8", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x1400027db", + "size": 2, + "mnemonic": "jne", + "operands": "0x140002823" + }, + { + "address": "0x1400027dd", + "size": 3, + "mnemonic": "test", + "operands": "rsi, rsi" + }, + { + "address": "0x1400027e0", + "size": 2, + "mnemonic": "je", + "operands": "0x1400027e7" + } + ], + "successors": [ + "0x1400027e7", + "0x1400027e2" + ] + }, + { + "address": "0x1400027e7", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400027e7", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbp" + }, + { + "address": "0x1400027ea", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x60]" + }, + { + "address": "0x1400027ef", + "size": 5, + "mnemonic": "call", + "operands": "0x140003188" + }, + { + "address": "0x1400027f4", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, -1" + }, + { + "address": "0x1400027f8", + "size": 2, + "mnemonic": "je", + "operands": "0x14000283b" + } + ], + "successors": [ + "0x14000283b", + "0x1400027fa" + ] + }, + { + "address": "0x1400027e2", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400027e2", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rsi" + }, + { + "address": "0x1400027e5", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140002823" + } + ], + "successors": [ + "0x140002823" + ] + }, + { + "address": "0x14000283b", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000283b", + "size": 5, + "mnemonic": "call", + "operands": "0x14000348c" + }, + { + "address": "0x140002840", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140002841", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400027fa", + "size": 19, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400027fa", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x60]" + }, + { + "address": "0x1400027ff", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x50], rbx" + }, + { + "address": "0x140002804", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140002807", + "size": 5, + "mnemonic": "call", + "operands": "0x140004614" + }, + { + "address": "0x14000280c", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx]" + }, + { + "address": "0x14000280f", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 8]" + }, + { + "address": "0x140002813", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140002816", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1daa4]" + }, + { + "address": "0x14000281c", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x2fac5], rbx" + }, + { + "address": "0x140002823", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x58]" + }, + { + "address": "0x140002828", + "size": 5, + "mnemonic": "call", + "operands": "0x140004504" + }, + { + "address": "0x14000282d", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140002830", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140002834", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140002836", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140002837", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140002838", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140002839", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000283a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140002823", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140002823", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x58]" + }, + { + "address": "0x140002828", + "size": 5, + "mnemonic": "call", + "operands": "0x140004504" + }, + { + "address": "0x14000282d", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140002830", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140002834", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140002836", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140002837", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140002838", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140002839", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000283a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400037f6", + "name": "", + "blocks": [ + { + "address": "0x1400037f6", + "size": 15, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400037f6", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x1400037f7", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x1400037f8", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x1400037fa", + "size": 5, + "mnemonic": "lea", + "operands": "rbp, [rsp - 0x47]" + }, + { + "address": "0x1400037ff", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x90" + }, + { + "address": "0x140003806", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x2d833]" + }, + { + "address": "0x14000380d", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x140003810", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x3f], rax" + }, + { + "address": "0x140003814", + "size": 3, + "mnemonic": "or", + "operands": "edi, 0xffffffff" + }, + { + "address": "0x140003817", + "size": 2, + "mnemonic": "mov", + "operands": "esi, edx" + }, + { + "address": "0x140003819", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14000381c", + "size": 2, + "mnemonic": "cmp", + "operands": "edx, edi" + }, + { + "address": "0x14000381e", + "size": 2, + "mnemonic": "jne", + "operands": "0x140003827" + }, + { + "address": "0x140003820", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140003822", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000394c" + } + ], + "successors": [ + "0x14000394c" + ] + }, + { + "address": "0x14000394c", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000394c", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x3f]" + }, + { + "address": "0x140003950", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x140003953", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140003958", + "size": 8, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x90]" + }, + { + "address": "0x140003960", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x30]" + }, + { + "address": "0x140003964", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x38]" + }, + { + "address": "0x140003968", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x14000396b", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000396d", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000396e", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000396f", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140003d8f", + "name": "", + "blocks": [ + { + "address": "0x140003d8f", + "size": 11, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140003d8f", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140003d90", + "size": 4, + "mnemonic": "lea", + "operands": "rbp, [rax - 0x5f]" + }, + { + "address": "0x140003d94", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x90" + }, + { + "address": "0x140003d9b", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x2d29e]" + }, + { + "address": "0x140003da2", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x140003da5", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x4f], rax" + }, + { + "address": "0x140003da9", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x140003dac", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0x38]" + }, + { + "address": "0x140003db0", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax]" + }, + { + "address": "0x140003db3", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140003db6", + "size": 2, + "mnemonic": "je", + "operands": "0x140003de4" + } + ], + "successors": [ + "0x140003de4", + "0x140003db8" + ] + }, + { + "address": "0x140003de4", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140003de4", + "size": 8, + "mnemonic": "cmp", + "operands": "qword ptr [rdi + 0x80], 0" + }, + { + "address": "0x140003dec", + "size": 2, + "mnemonic": "jne", + "operands": "0x140003df6" + }, + { + "address": "0x140003dee", + "size": 3, + "mnemonic": "or", + "operands": "eax, 0xffffffff" + }, + { + "address": "0x140003df1", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140003f7b" + } + ], + "successors": [ + "0x140003f7b" + ] + }, + { + "address": "0x140003db8", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140003db8", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rdi + 0x50]" + }, + { + "address": "0x140003dbc", + "size": 3, + "mnemonic": "movsxd", + "operands": "r9, dword ptr [rdx]" + }, + { + "address": "0x140003dbf", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rcx + r9]" + }, + { + "address": "0x140003dc3", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, rax" + }, + { + "address": "0x140003dc6", + "size": 2, + "mnemonic": "jae", + "operands": "0x140003de4" + }, + { + "address": "0x140003dc8", + "size": 4, + "mnemonic": "lea", + "operands": "eax, [r9 - 1]" + }, + { + "address": "0x140003dcc", + "size": 2, + "mnemonic": "mov", + "operands": "dword ptr [rdx], eax" + }, + { + "address": "0x140003dce", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdi + 0x38]" + }, + { + "address": "0x140003dd2", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rcx]" + }, + { + "address": "0x140003dd5", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rdx + 1]" + }, + { + "address": "0x140003dd9", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rcx], rax" + }, + { + "address": "0x140003ddc", + "size": 3, + "mnemonic": "movzx", + "operands": "eax, byte ptr [rdx]" + }, + { + "address": "0x140003ddf", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140003f7b" + } + ], + "successors": [ + "0x140003f7b" + ] + }, + { + "address": "0x140003f7b", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140003f7b", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x4f]" + }, + { + "address": "0x140003f7f", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x140003f82", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140003f87", + "size": 8, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x90]" + }, + { + "address": "0x140003f8f", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x18]" + }, + { + "address": "0x140003f93", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x20]" + }, + { + "address": "0x140003f97", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x28]" + }, + { + "address": "0x140003f9b", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x140003f9e", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140003f9f", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400049dd", + "name": "", + "blocks": [ + { + "address": "0x1400049dd", + "size": 13, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400049dd", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x1400049de", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x1400049df", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x1400049e0", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x1400049e4", + "size": 3, + "mnemonic": "movsxd", + "operands": "rbx, ecx" + }, + { + "address": "0x1400049e7", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x1400049ea", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x1400049ed", + "size": 2, + "mnemonic": "jne", + "operands": "0x140004a01" + }, + { + "address": "0x1400049ef", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cfb8" + }, + { + "address": "0x1400049f4", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rax + 0x10]" + }, + { + "address": "0x1400049f8", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cf88" + }, + { + "address": "0x1400049fd", + "size": 2, + "mnemonic": "mov", + "operands": "ebp, eax" + }, + { + "address": "0x1400049ff", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140004a07" + } + ], + "successors": [ + "0x140004a07" + ] + }, + { + "address": "0x140004a07", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004a07", + "size": 3, + "mnemonic": "test", + "operands": "rsi, rsi" + }, + { + "address": "0x140004a0a", + "size": 2, + "mnemonic": "jne", + "operands": "0x140004a1d" + }, + { + "address": "0x140004a0c", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rbx - 0x41]" + }, + { + "address": "0x140004a0f", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, 0x19" + }, + { + "address": "0x140004a12", + "size": 3, + "mnemonic": "lea", + "operands": "eax, [rbx + 0x20]" + }, + { + "address": "0x140004a15", + "size": 3, + "mnemonic": "cmova", + "operands": "eax, ebx" + }, + { + "address": "0x140004a18", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140004afa" + } + ], + "successors": [ + "0x140004afa" + ] + }, + { + "address": "0x140004afa", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140004afa", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x60]" + }, + { + "address": "0x140004aff", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x40" + }, + { + "address": "0x140004b03", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140004b04", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140004b05", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140004b06", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140004e28", + "name": "", + "blocks": [ + { + "address": "0x140004e28", + "size": 24, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004e28", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140004e2a", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140004e2c", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140004e2e", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x140004e32", + "size": 5, + "mnemonic": "lea", + "operands": "rbp, [rsp + 0x50]" + }, + { + "address": "0x140004e37", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x30], rbx" + }, + { + "address": "0x140004e3b", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x38], rsi" + }, + { + "address": "0x140004e3f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x40], rdi" + }, + { + "address": "0x140004e43", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x48], r13" + }, + { + "address": "0x140004e47", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x2c1f2]" + }, + { + "address": "0x140004e4e", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rbp" + }, + { + "address": "0x140004e51", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp], rax" + }, + { + "address": "0x140004e55", + "size": 3, + "mnemonic": "movsxd", + "operands": "rdi, r9d" + }, + { + "address": "0x140004e58", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, r8" + }, + { + "address": "0x140004e5b", + "size": 3, + "mnemonic": "mov", + "operands": "r15d, edx" + }, + { + "address": "0x140004e5e", + "size": 3, + "mnemonic": "mov", + "operands": "r13, rcx" + }, + { + "address": "0x140004e61", + "size": 3, + "mnemonic": "test", + "operands": "r9d, r9d" + }, + { + "address": "0x140004e64", + "size": 2, + "mnemonic": "jle", + "operands": "0x140004e7a" + }, + { + "address": "0x140004e66", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rdi" + }, + { + "address": "0x140004e69", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r8" + }, + { + "address": "0x140004e6c", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d9c0" + }, + { + "address": "0x140004e71", + "size": 2, + "mnemonic": "cmp", + "operands": "eax, edi" + }, + { + "address": "0x140004e73", + "size": 3, + "mnemonic": "lea", + "operands": "edi, [rax + 1]" + }, + { + "address": "0x140004e76", + "size": 2, + "mnemonic": "jl", + "operands": "0x140004e7a" + } + ], + "successors": [ + "0x140004e7a", + "0x140004e78" + ] + }, + { + "address": "0x140004e7a", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004e7a", + "size": 3, + "mnemonic": "neg", + "operands": "dword ptr [rbp + 0x68]" + }, + { + "address": "0x140004e7d", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, edi" + }, + { + "address": "0x140004e80", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbp + 0x60]" + }, + { + "address": "0x140004e83", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rsi" + }, + { + "address": "0x140004e86", + "size": 2, + "mnemonic": "sbb", + "operands": "edx, edx" + }, + { + "address": "0x140004e88", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], 0" + }, + { + "address": "0x140004e90", + "size": 3, + "mnemonic": "and", + "operands": "edx, 8" + }, + { + "address": "0x140004e93", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], 0" + }, + { + "address": "0x140004e9c", + "size": 2, + "mnemonic": "inc", + "operands": "edx" + }, + { + "address": "0x140004e9e", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1b18c]" + }, + { + "address": "0x140004ea4", + "size": 3, + "mnemonic": "movsxd", + "operands": "r14, eax" + }, + { + "address": "0x140004ea7", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140004ea9", + "size": 6, + "mnemonic": "je", + "operands": "0x140004f56" + } + ], + "successors": [ + "0x140004f56", + "0x140004eaf" + ] + }, + { + "address": "0x140004e78", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004e78", + "size": 2, + "mnemonic": "mov", + "operands": "edi, eax" + }, + { + "address": "0x140004e7a", + "size": 3, + "mnemonic": "neg", + "operands": "dword ptr [rbp + 0x68]" + }, + { + "address": "0x140004e7d", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, edi" + }, + { + "address": "0x140004e80", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbp + 0x60]" + }, + { + "address": "0x140004e83", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rsi" + }, + { + "address": "0x140004e86", + "size": 2, + "mnemonic": "sbb", + "operands": "edx, edx" + }, + { + "address": "0x140004e88", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], 0" + }, + { + "address": "0x140004e90", + "size": 3, + "mnemonic": "and", + "operands": "edx, 8" + }, + { + "address": "0x140004e93", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], 0" + }, + { + "address": "0x140004e9c", + "size": 2, + "mnemonic": "inc", + "operands": "edx" + }, + { + "address": "0x140004e9e", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1b18c]" + }, + { + "address": "0x140004ea4", + "size": 3, + "mnemonic": "movsxd", + "operands": "r14, eax" + }, + { + "address": "0x140004ea7", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140004ea9", + "size": 6, + "mnemonic": "je", + "operands": "0x140004f56" + } + ], + "successors": [ + "0x140004f56", + "0x140004eaf" + ] + }, + { + "address": "0x140004f56", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140004f56", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140004f58", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp]" + }, + { + "address": "0x140004f5c", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rbp" + }, + { + "address": "0x140004f5f", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140004f64", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rbp + 0x30]" + }, + { + "address": "0x140004f68", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rbp + 0x38]" + }, + { + "address": "0x140004f6c", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rbp + 0x40]" + }, + { + "address": "0x140004f70", + "size": 4, + "mnemonic": "mov", + "operands": "r13, qword ptr [rbp + 0x48]" + }, + { + "address": "0x140004f74", + "size": 4, + "mnemonic": "lea", + "operands": "rsp, [rbp + 0x10]" + }, + { + "address": "0x140004f78", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140004f7a", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140004f7c", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140004f7d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140004eaf", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004eaf", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r14" + }, + { + "address": "0x140004eb2", + "size": 3, + "mnemonic": "add", + "operands": "rcx, rcx" + }, + { + "address": "0x140004eb5", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rcx + 0x10]" + }, + { + "address": "0x140004eb9", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, rdx" + }, + { + "address": "0x140004ebc", + "size": 3, + "mnemonic": "sbb", + "operands": "rcx, rcx" + }, + { + "address": "0x140004ebf", + "size": 3, + "mnemonic": "and", + "operands": "rcx, rdx" + }, + { + "address": "0x140004ec2", + "size": 6, + "mnemonic": "je", + "operands": "0x140004f56" + } + ], + "successors": [ + "0x140004f56", + "0x140004ec8" + ] + }, + { + "address": "0x140004ec8", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004ec8", + "size": 10, + "mnemonic": "movabs", + "operands": "rdx, 0xffffffffffffff0" + }, + { + "address": "0x140004ed2", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, 0x400" + }, + { + "address": "0x140004ed9", + "size": 2, + "mnemonic": "ja", + "operands": "0x140004f05" + } + ], + "successors": [ + "0x140004f05", + "0x140004edb" + ] + }, + { + "address": "0x140004f05", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004f05", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cac0" + }, + { + "address": "0x140004f0a", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x140004f0d", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140004f10", + "size": 2, + "mnemonic": "je", + "operands": "0x140004f1c" + } + ], + "successors": [ + "0x140004f1c", + "0x140004f12" + ] + }, + { + "address": "0x140004edb", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004edb", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rcx + 0xf]" + }, + { + "address": "0x140004edf", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, rcx" + }, + { + "address": "0x140004ee2", + "size": 2, + "mnemonic": "ja", + "operands": "0x140004ee7" + } + ], + "successors": [ + "0x140004ee7", + "0x140004ee4" + ] + }, + { + "address": "0x140004f1c", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004f1c", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x140004f1f", + "size": 2, + "mnemonic": "je", + "operands": "0x140004f56" + } + ], + "successors": [ + "0x140004f56", + "0x140004f21" + ] + }, + { + "address": "0x140004f12", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004f12", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0xdddd" + }, + { + "address": "0x140004f18", + "size": 4, + "mnemonic": "add", + "operands": "rbx, 0x10" + }, + { + "address": "0x140004f1c", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x140004f1f", + "size": 2, + "mnemonic": "je", + "operands": "0x140004f56" + } + ], + "successors": [ + "0x140004f56", + "0x140004f21" + ] + }, + { + "address": "0x140004ee7", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004ee7", + "size": 4, + "mnemonic": "and", + "operands": "rax, 0xfffffffffffffff0" + }, + { + "address": "0x140004eeb", + "size": 5, + "mnemonic": "call", + "operands": "0x1400057a0" + }, + { + "address": "0x140004ef0", + "size": 3, + "mnemonic": "sub", + "operands": "rsp, rax" + }, + { + "address": "0x140004ef3", + "size": 5, + "mnemonic": "lea", + "operands": "rbx, [rsp + 0x50]" + }, + { + "address": "0x140004ef8", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x140004efb", + "size": 2, + "mnemonic": "je", + "operands": "0x140004f56" + } + ], + "successors": [ + "0x140004f56", + "0x140004efd" + ] + }, + { + "address": "0x140004ee4", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004ee4", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdx" + }, + { + "address": "0x140004ee7", + "size": 4, + "mnemonic": "and", + "operands": "rax, 0xfffffffffffffff0" + }, + { + "address": "0x140004eeb", + "size": 5, + "mnemonic": "call", + "operands": "0x1400057a0" + }, + { + "address": "0x140004ef0", + "size": 3, + "mnemonic": "sub", + "operands": "rsp, rax" + }, + { + "address": "0x140004ef3", + "size": 5, + "mnemonic": "lea", + "operands": "rbx, [rsp + 0x50]" + }, + { + "address": "0x140004ef8", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x140004efb", + "size": 2, + "mnemonic": "je", + "operands": "0x140004f56" + } + ], + "successors": [ + "0x140004f56", + "0x140004efd" + ] + }, + { + "address": "0x140004f21", + "size": 27, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140004f21", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbp + 0x60]" + }, + { + "address": "0x140004f24", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, edi" + }, + { + "address": "0x140004f27", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], r14d" + }, + { + "address": "0x140004f2c", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rsi" + }, + { + "address": "0x140004f2f", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 1" + }, + { + "address": "0x140004f34", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rbx" + }, + { + "address": "0x140004f39", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1b0f1]" + }, + { + "address": "0x140004f3f", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x140004f41", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140004f43", + "size": 2, + "mnemonic": "jne", + "operands": "0x140004f7e" + }, + { + "address": "0x140004f45", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbx - 0x10]" + }, + { + "address": "0x140004f49", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rcx], 0xdddd" + }, + { + "address": "0x140004f4f", + "size": 2, + "mnemonic": "jne", + "operands": "0x140004f56" + }, + { + "address": "0x140004f51", + "size": 5, + "mnemonic": "call", + "operands": "0x14000c9d0" + }, + { + "address": "0x140004f56", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140004f58", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp]" + }, + { + "address": "0x140004f5c", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rbp" + }, + { + "address": "0x140004f5f", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140004f64", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rbp + 0x30]" + }, + { + "address": "0x140004f68", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rbp + 0x38]" + }, + { + "address": "0x140004f6c", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rbp + 0x40]" + }, + { + "address": "0x140004f70", + "size": 4, + "mnemonic": "mov", + "operands": "r13, qword ptr [rbp + 0x48]" + }, + { + "address": "0x140004f74", + "size": 4, + "mnemonic": "lea", + "operands": "rsp, [rbp + 0x10]" + }, + { + "address": "0x140004f78", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140004f7a", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140004f7c", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140004f7d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140004efd", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004efd", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rbx], 0xcccc" + }, + { + "address": "0x140004f03", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140004f18" + } + ], + "successors": [ + "0x140004f18" + ] + }, + { + "address": "0x140004f18", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004f18", + "size": 4, + "mnemonic": "add", + "operands": "rbx, 0x10" + }, + { + "address": "0x140004f1c", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x140004f1f", + "size": 2, + "mnemonic": "je", + "operands": "0x140004f56" + } + ], + "successors": [ + "0x140004f56", + "0x140004f21" + ] + } + ] + }, + { + "address": "0x140005d35", + "name": "", + "blocks": [ + { + "address": "0x140005d35", + "size": 38, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x140005d35", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140005d36", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x140005d39", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x140005d3d", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x2b2fc]" + }, + { + "address": "0x140005d44", + "size": 10, + "mnemonic": "movabs", + "operands": "rbx, 0x2b992ddfa232" + }, + { + "address": "0x140005d4e", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, rbx" + }, + { + "address": "0x140005d51", + "size": 2, + "mnemonic": "jne", + "operands": "0x140005dca" + }, + { + "address": "0x140005d53", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x10]" + }, + { + "address": "0x140005d57", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x10], 0" + }, + { + "address": "0x140005d5f", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a34b]" + }, + { + "address": "0x140005d65", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x10]" + }, + { + "address": "0x140005d69", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x10], rax" + }, + { + "address": "0x140005d6d", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a335]" + }, + { + "address": "0x140005d73", + "size": 2, + "mnemonic": "mov", + "operands": "eax, eax" + }, + { + "address": "0x140005d75", + "size": 4, + "mnemonic": "xor", + "operands": "qword ptr [rbp - 0x10], rax" + }, + { + "address": "0x140005d79", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a321]" + }, + { + "address": "0x140005d7f", + "size": 2, + "mnemonic": "mov", + "operands": "eax, eax" + }, + { + "address": "0x140005d81", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x18]" + }, + { + "address": "0x140005d85", + "size": 4, + "mnemonic": "xor", + "operands": "qword ptr [rbp - 0x10], rax" + }, + { + "address": "0x140005d89", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a309]" + }, + { + "address": "0x140005d8f", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbp + 0x18]" + }, + { + "address": "0x140005d92", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x140005d96", + "size": 4, + "mnemonic": "shl", + "operands": "rax, 0x20" + }, + { + "address": "0x140005d9a", + "size": 4, + "mnemonic": "xor", + "operands": "rax, qword ptr [rbp + 0x18]" + }, + { + "address": "0x140005d9e", + "size": 4, + "mnemonic": "xor", + "operands": "rax, qword ptr [rbp - 0x10]" + }, + { + "address": "0x140005da2", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rcx" + }, + { + "address": "0x140005da5", + "size": 10, + "mnemonic": "movabs", + "operands": "rcx, 0xffffffffffff" + }, + { + "address": "0x140005daf", + "size": 3, + "mnemonic": "and", + "operands": "rax, rcx" + }, + { + "address": "0x140005db2", + "size": 10, + "mnemonic": "movabs", + "operands": "rcx, 0x2b992ddfa233" + }, + { + "address": "0x140005dbc", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, rbx" + }, + { + "address": "0x140005dbf", + "size": 4, + "mnemonic": "cmove", + "operands": "rax, rcx" + }, + { + "address": "0x140005dc3", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x2b276], rax" + }, + { + "address": "0x140005dca", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x50]" + }, + { + "address": "0x140005dcf", + "size": 3, + "mnemonic": "not", + "operands": "rax" + }, + { + "address": "0x140005dd2", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x2b2a7], rax" + }, + { + "address": "0x140005dd9", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140005ddd", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140005dde", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140005e49", + "name": "", + "blocks": [ + { + "address": "0x140005e49", + "size": 8, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005e49", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140005e4a", + "size": 8, + "mnemonic": "lea", + "operands": "rbp, [rsp - 0x4c0]" + }, + { + "address": "0x140005e52", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x5c0" + }, + { + "address": "0x140005e59", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, ecx" + }, + { + "address": "0x140005e5b", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0x17" + }, + { + "address": "0x140005e60", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a22a]" + }, + { + "address": "0x140005e66", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140005e68", + "size": 2, + "mnemonic": "je", + "operands": "0x140005e6e" + } + ], + "successors": [ + "0x140005e6e", + "0x140005e6a" + ] + } + ] + }, + { + "address": "0x140006908", + "name": "", + "blocks": [ + { + "address": "0x140006908", + "size": 59, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x140006908", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000690a", + "size": 5, + "mnemonic": "lea", + "operands": "rbp, [rsp - 0x1f]" + }, + { + "address": "0x14000690f", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0xe0" + }, + { + "address": "0x140006916", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x2a723]" + }, + { + "address": "0x14000691d", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x140006920", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0xf], rax" + }, + { + "address": "0x140006924", + "size": 4, + "mnemonic": "mov", + "operands": "r10, qword ptr [rbp + 0x77]" + }, + { + "address": "0x140006928", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1d521]" + }, + { + "address": "0x14000692f", + "size": 3, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rax]" + }, + { + "address": "0x140006932", + "size": 3, + "mnemonic": "mov", + "operands": "r11, rcx" + }, + { + "address": "0x140006935", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x30]" + }, + { + "address": "0x14000693a", + "size": 4, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rax + 0x10]" + }, + { + "address": "0x14000693e", + "size": 3, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx], xmm0" + }, + { + "address": "0x140006941", + "size": 4, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rax + 0x20]" + }, + { + "address": "0x140006945", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx + 0x10], xmm1" + }, + { + "address": "0x140006949", + "size": 4, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rax + 0x30]" + }, + { + "address": "0x14000694d", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx + 0x20], xmm0" + }, + { + "address": "0x140006951", + "size": 4, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rax + 0x40]" + }, + { + "address": "0x140006955", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx + 0x30], xmm1" + }, + { + "address": "0x140006959", + "size": 4, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rax + 0x50]" + }, + { + "address": "0x14000695d", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx + 0x40], xmm0" + }, + { + "address": "0x140006961", + "size": 4, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rax + 0x60]" + }, + { + "address": "0x140006965", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx + 0x50], xmm1" + }, + { + "address": "0x140006969", + "size": 7, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rax + 0x80]" + }, + { + "address": "0x140006970", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx + 0x60], xmm0" + }, + { + "address": "0x140006974", + "size": 4, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rax + 0x70]" + }, + { + "address": "0x140006978", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax + 0x90]" + }, + { + "address": "0x14000697f", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx + 0x70], xmm0" + }, + { + "address": "0x140006983", + "size": 7, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx + 0x80], xmm1" + }, + { + "address": "0x14000698a", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 0x90], rax" + }, + { + "address": "0x140006991", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x2db0]" + }, + { + "address": "0x140006998", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r11]" + }, + { + "address": "0x14000699b", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x71], rax" + }, + { + "address": "0x14000699f", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x4f]" + }, + { + "address": "0x1400069a3", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x61], rax" + }, + { + "address": "0x1400069a7", + "size": 4, + "mnemonic": "movsxd", + "operands": "rax, dword ptr [rbp + 0x5f]" + }, + { + "address": "0x1400069ab", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x59], rax" + }, + { + "address": "0x1400069af", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x57]" + }, + { + "address": "0x1400069b3", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x49], rax" + }, + { + "address": "0x1400069b7", + "size": 4, + "mnemonic": "movzx", + "operands": "eax, byte ptr [rbp + 0x7f]" + }, + { + "address": "0x1400069bb", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x39], rax" + }, + { + "address": "0x1400069bf", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [r10 + 0x40]" + }, + { + "address": "0x1400069c3", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x1400069c8", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [r10 + 0x28]" + }, + { + "address": "0x1400069cc", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x69], r9" + }, + { + "address": "0x1400069d0", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x1400069d3", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x51], r8" + }, + { + "address": "0x1400069d7", + "size": 5, + "mnemonic": "lea", + "operands": "r8, [rsp + 0x30]" + }, + { + "address": "0x1400069dc", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x41], rdx" + }, + { + "address": "0x1400069e0", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [r10]" + }, + { + "address": "0x1400069e3", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x1400069e8", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x31], 0x19930520" + }, + { + "address": "0x1400069f0", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x196fa]" + }, + { + "address": "0x1400069f6", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0xf]" + }, + { + "address": "0x1400069fa", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x1400069fd", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140006a02", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0xe0" + }, + { + "address": "0x140006a09", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140006a0a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140006a0c", + "name": "", + "blocks": [ + { + "address": "0x140006a0c", + "size": 66, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x140006a0c", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140006a0e", + "size": 5, + "mnemonic": "lea", + "operands": "rbp, [rsp - 0x1f]" + }, + { + "address": "0x140006a13", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0xe0" + }, + { + "address": "0x140006a1a", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x2a61f]" + }, + { + "address": "0x140006a21", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x140006a24", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0xf], rax" + }, + { + "address": "0x140006a28", + "size": 4, + "mnemonic": "mov", + "operands": "r10, qword ptr [rbp + 0x77]" + }, + { + "address": "0x140006a2c", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1d37d]" + }, + { + "address": "0x140006a33", + "size": 3, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rax]" + }, + { + "address": "0x140006a36", + "size": 3, + "mnemonic": "mov", + "operands": "r11, rcx" + }, + { + "address": "0x140006a39", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x30]" + }, + { + "address": "0x140006a3e", + "size": 4, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rax + 0x10]" + }, + { + "address": "0x140006a42", + "size": 3, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx], xmm0" + }, + { + "address": "0x140006a45", + "size": 4, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rax + 0x20]" + }, + { + "address": "0x140006a49", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx + 0x10], xmm1" + }, + { + "address": "0x140006a4d", + "size": 4, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rax + 0x30]" + }, + { + "address": "0x140006a51", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx + 0x20], xmm0" + }, + { + "address": "0x140006a55", + "size": 4, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rax + 0x40]" + }, + { + "address": "0x140006a59", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx + 0x30], xmm1" + }, + { + "address": "0x140006a5d", + "size": 4, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rax + 0x50]" + }, + { + "address": "0x140006a61", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx + 0x40], xmm0" + }, + { + "address": "0x140006a65", + "size": 4, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rax + 0x60]" + }, + { + "address": "0x140006a69", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx + 0x50], xmm1" + }, + { + "address": "0x140006a6d", + "size": 7, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rax + 0x80]" + }, + { + "address": "0x140006a74", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx + 0x60], xmm0" + }, + { + "address": "0x140006a78", + "size": 4, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rax + 0x70]" + }, + { + "address": "0x140006a7c", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax + 0x90]" + }, + { + "address": "0x140006a83", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx + 0x70], xmm0" + }, + { + "address": "0x140006a87", + "size": 7, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx + 0x80], xmm1" + }, + { + "address": "0x140006a8e", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 0x90], rax" + }, + { + "address": "0x140006a95", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x2e98]" + }, + { + "address": "0x140006a9c", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x71], rax" + }, + { + "address": "0x140006aa0", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x4f]" + }, + { + "address": "0x140006aa4", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x61], rax" + }, + { + "address": "0x140006aa8", + "size": 4, + "mnemonic": "movsxd", + "operands": "rax, dword ptr [rbp + 0x5f]" + }, + { + "address": "0x140006aac", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x51], r8" + }, + { + "address": "0x140006ab0", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [rbp + 0x6f]" + }, + { + "address": "0x140006ab4", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x59], rax" + }, + { + "address": "0x140006ab8", + "size": 4, + "mnemonic": "movzx", + "operands": "eax, byte ptr [rbp + 0x7f]" + }, + { + "address": "0x140006abc", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x39], rax" + }, + { + "address": "0x140006ac0", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r8 + 0x18]" + }, + { + "address": "0x140006ac4", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [r8 + 0x20]" + }, + { + "address": "0x140006ac8", + "size": 4, + "mnemonic": "add", + "operands": "rcx, qword ptr [r10 + 8]" + }, + { + "address": "0x140006acc", + "size": 4, + "mnemonic": "add", + "operands": "r8, qword ptr [r10 + 8]" + }, + { + "address": "0x140006ad0", + "size": 4, + "mnemonic": "movsxd", + "operands": "rax, dword ptr [rbp + 0x67]" + }, + { + "address": "0x140006ad4", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x19], rax" + }, + { + "address": "0x140006ad8", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [r10 + 0x40]" + }, + { + "address": "0x140006adc", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x140006ae1", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [r10 + 0x28]" + }, + { + "address": "0x140006ae5", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x69], r9" + }, + { + "address": "0x140006ae9", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x140006aec", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x49], rcx" + }, + { + "address": "0x140006af0", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r11]" + }, + { + "address": "0x140006af3", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x41], rdx" + }, + { + "address": "0x140006af7", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [r10]" + }, + { + "address": "0x140006afa", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x29], r8" + }, + { + "address": "0x140006afe", + "size": 5, + "mnemonic": "lea", + "operands": "r8, [rsp + 0x30]" + }, + { + "address": "0x140006b03", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x140006b08", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x31], 0x19930520" + }, + { + "address": "0x140006b10", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x195da]" + }, + { + "address": "0x140006b16", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0xf]" + }, + { + "address": "0x140006b1a", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x140006b1d", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140006b22", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0xe0" + }, + { + "address": "0x140006b29", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140006b2a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140007cbb", + "name": "", + "blocks": [ + { + "address": "0x140007cbb", + "size": 21, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007cbb", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140007cbc", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140007cbd", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140007cbe", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140007cc0", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140007cc2", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140007cc4", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140007cc6", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x140007cca", + "size": 8, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsp + 0xc0]" + }, + { + "address": "0x140007cd2", + "size": 3, + "mnemonic": "mov", + "operands": "r12, r9" + }, + { + "address": "0x140007cd5", + "size": 3, + "mnemonic": "mov", + "operands": "r13, rdx" + }, + { + "address": "0x140007cd8", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rax + 0x10]" + }, + { + "address": "0x140007cdc", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rcx" + }, + { + "address": "0x140007cdf", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r12" + }, + { + "address": "0x140007ce2", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r13" + }, + { + "address": "0x140007ce5", + "size": 5, + "mnemonic": "call", + "operands": "0x140006544" + }, + { + "address": "0x140007cea", + "size": 8, + "mnemonic": "mov", + "operands": "r9, qword ptr [rsp + 0xd0]" + }, + { + "address": "0x140007cf2", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rax" + }, + { + "address": "0x140007cf5", + "size": 8, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0xc8]" + }, + { + "address": "0x140007cfd", + "size": 3, + "mnemonic": "test", + "operands": "r9, r9" + }, + { + "address": "0x140007d00", + "size": 2, + "mnemonic": "je", + "operands": "0x140007d10" + } + ], + "successors": [ + "0x140007d10", + "0x140007d02" + ] + }, + { + "address": "0x140007d10", + "size": 30, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140007d10", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0xd8]" + }, + { + "address": "0x140007d18", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rbp + 0xc]" + }, + { + "address": "0x140007d1c", + "size": 3, + "mnemonic": "mov", + "operands": "edi, dword ptr [rcx + 8]" + }, + { + "address": "0x140007d1f", + "size": 2, + "mnemonic": "mov", + "operands": "esi, dword ptr [rcx]" + }, + { + "address": "0x140007d21", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140007d26", + "size": 7, + "mnemonic": "mov", + "operands": "cl, byte ptr [rsp + 0xf8]" + }, + { + "address": "0x140007d2d", + "size": 3, + "mnemonic": "add", + "operands": "rax, rbx" + }, + { + "address": "0x140007d30", + "size": 8, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsp + 0xb0]" + }, + { + "address": "0x140007d38", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r15" + }, + { + "address": "0x140007d3b", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x50], cl" + }, + { + "address": "0x140007d3f", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r14" + }, + { + "address": "0x140007d42", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0xc0]" + }, + { + "address": "0x140007d4a", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x48], r12" + }, + { + "address": "0x140007d4f", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x40], rbp" + }, + { + "address": "0x140007d54", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x38], edi" + }, + { + "address": "0x140007d58", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x30], esi" + }, + { + "address": "0x140007d5c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rcx" + }, + { + "address": "0x140007d61", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r13" + }, + { + "address": "0x140007d64", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x140007d69", + "size": 5, + "mnemonic": "call", + "operands": "0x140006908" + }, + { + "address": "0x140007d6e", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0xa0]" + }, + { + "address": "0x140007d76", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x140007d7a", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140007d7c", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140007d7e", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140007d80", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140007d82", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140007d83", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140007d84", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140007d85", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140007d02", + "size": 34, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140007d02", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rbp" + }, + { + "address": "0x140007d05", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rax" + }, + { + "address": "0x140007d08", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r14" + }, + { + "address": "0x140007d0b", + "size": 5, + "mnemonic": "call", + "operands": "0x140007b2c" + }, + { + "address": "0x140007d10", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0xd8]" + }, + { + "address": "0x140007d18", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rbp + 0xc]" + }, + { + "address": "0x140007d1c", + "size": 3, + "mnemonic": "mov", + "operands": "edi, dword ptr [rcx + 8]" + }, + { + "address": "0x140007d1f", + "size": 2, + "mnemonic": "mov", + "operands": "esi, dword ptr [rcx]" + }, + { + "address": "0x140007d21", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140007d26", + "size": 7, + "mnemonic": "mov", + "operands": "cl, byte ptr [rsp + 0xf8]" + }, + { + "address": "0x140007d2d", + "size": 3, + "mnemonic": "add", + "operands": "rax, rbx" + }, + { + "address": "0x140007d30", + "size": 8, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsp + 0xb0]" + }, + { + "address": "0x140007d38", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r15" + }, + { + "address": "0x140007d3b", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x50], cl" + }, + { + "address": "0x140007d3f", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r14" + }, + { + "address": "0x140007d42", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0xc0]" + }, + { + "address": "0x140007d4a", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x48], r12" + }, + { + "address": "0x140007d4f", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x40], rbp" + }, + { + "address": "0x140007d54", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x38], edi" + }, + { + "address": "0x140007d58", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x30], esi" + }, + { + "address": "0x140007d5c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rcx" + }, + { + "address": "0x140007d61", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r13" + }, + { + "address": "0x140007d64", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x140007d69", + "size": 5, + "mnemonic": "call", + "operands": "0x140006908" + }, + { + "address": "0x140007d6e", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0xa0]" + }, + { + "address": "0x140007d76", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x140007d7a", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140007d7c", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140007d7e", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140007d80", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140007d82", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140007d83", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140007d84", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140007d85", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140007d93", + "name": "", + "blocks": [ + { + "address": "0x140007d93", + "size": 21, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007d93", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140007d94", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140007d95", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140007d96", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140007d98", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140007d9a", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140007d9c", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140007d9e", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x140007da2", + "size": 8, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsp + 0xc0]" + }, + { + "address": "0x140007daa", + "size": 3, + "mnemonic": "mov", + "operands": "r12, r9" + }, + { + "address": "0x140007dad", + "size": 3, + "mnemonic": "mov", + "operands": "r13, rdx" + }, + { + "address": "0x140007db0", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rax + 0x10]" + }, + { + "address": "0x140007db4", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rcx" + }, + { + "address": "0x140007db7", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r12" + }, + { + "address": "0x140007dba", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r13" + }, + { + "address": "0x140007dbd", + "size": 5, + "mnemonic": "call", + "operands": "0x14000662c" + }, + { + "address": "0x140007dc2", + "size": 8, + "mnemonic": "mov", + "operands": "r9, qword ptr [rsp + 0xd0]" + }, + { + "address": "0x140007dca", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rax" + }, + { + "address": "0x140007dcd", + "size": 8, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0xc8]" + }, + { + "address": "0x140007dd5", + "size": 3, + "mnemonic": "test", + "operands": "r9, r9" + }, + { + "address": "0x140007dd8", + "size": 2, + "mnemonic": "je", + "operands": "0x140007de8" + } + ], + "successors": [ + "0x140007de8", + "0x140007dda" + ] + }, + { + "address": "0x140007de8", + "size": 30, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140007de8", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0xd8]" + }, + { + "address": "0x140007df0", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rbp + 0x10]" + }, + { + "address": "0x140007df4", + "size": 3, + "mnemonic": "mov", + "operands": "edi, dword ptr [rcx + 8]" + }, + { + "address": "0x140007df7", + "size": 2, + "mnemonic": "mov", + "operands": "esi, dword ptr [rcx]" + }, + { + "address": "0x140007df9", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140007dfe", + "size": 7, + "mnemonic": "mov", + "operands": "cl, byte ptr [rsp + 0xf8]" + }, + { + "address": "0x140007e05", + "size": 3, + "mnemonic": "add", + "operands": "rax, rbx" + }, + { + "address": "0x140007e08", + "size": 8, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsp + 0xb0]" + }, + { + "address": "0x140007e10", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r15" + }, + { + "address": "0x140007e13", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x50], cl" + }, + { + "address": "0x140007e17", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r14" + }, + { + "address": "0x140007e1a", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0xc0]" + }, + { + "address": "0x140007e22", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x48], r12" + }, + { + "address": "0x140007e27", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x40], rbp" + }, + { + "address": "0x140007e2c", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x38], edi" + }, + { + "address": "0x140007e30", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x30], esi" + }, + { + "address": "0x140007e34", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rcx" + }, + { + "address": "0x140007e39", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r13" + }, + { + "address": "0x140007e3c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x140007e41", + "size": 5, + "mnemonic": "call", + "operands": "0x140006a0c" + }, + { + "address": "0x140007e46", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0xa0]" + }, + { + "address": "0x140007e4e", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x140007e52", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140007e54", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140007e56", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140007e58", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140007e5a", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140007e5b", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140007e5c", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140007e5d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140007dda", + "size": 34, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140007dda", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rbp" + }, + { + "address": "0x140007ddd", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rax" + }, + { + "address": "0x140007de0", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r14" + }, + { + "address": "0x140007de3", + "size": 5, + "mnemonic": "call", + "operands": "0x140007bec" + }, + { + "address": "0x140007de8", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0xd8]" + }, + { + "address": "0x140007df0", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rbp + 0x10]" + }, + { + "address": "0x140007df4", + "size": 3, + "mnemonic": "mov", + "operands": "edi, dword ptr [rcx + 8]" + }, + { + "address": "0x140007df7", + "size": 2, + "mnemonic": "mov", + "operands": "esi, dword ptr [rcx]" + }, + { + "address": "0x140007df9", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140007dfe", + "size": 7, + "mnemonic": "mov", + "operands": "cl, byte ptr [rsp + 0xf8]" + }, + { + "address": "0x140007e05", + "size": 3, + "mnemonic": "add", + "operands": "rax, rbx" + }, + { + "address": "0x140007e08", + "size": 8, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsp + 0xb0]" + }, + { + "address": "0x140007e10", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r15" + }, + { + "address": "0x140007e13", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x50], cl" + }, + { + "address": "0x140007e17", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r14" + }, + { + "address": "0x140007e1a", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0xc0]" + }, + { + "address": "0x140007e22", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x48], r12" + }, + { + "address": "0x140007e27", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x40], rbp" + }, + { + "address": "0x140007e2c", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x38], edi" + }, + { + "address": "0x140007e30", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x30], esi" + }, + { + "address": "0x140007e34", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rcx" + }, + { + "address": "0x140007e39", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r13" + }, + { + "address": "0x140007e3c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x140007e41", + "size": 5, + "mnemonic": "call", + "operands": "0x140006a0c" + }, + { + "address": "0x140007e46", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0xa0]" + }, + { + "address": "0x140007e4e", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x140007e52", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140007e54", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140007e56", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140007e58", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140007e5a", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140007e5b", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140007e5c", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140007e5d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140007e60", + "name": "", + "blocks": [ + { + "address": "0x140007e60", + "size": 31, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007e60", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140007e62", + "size": 1, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140007e63", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140007e64", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140007e65", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140007e67", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140007e69", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140007e6b", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140007e6d", + "size": 5, + "mnemonic": "lea", + "operands": "rbp, [rsp - 0x28]" + }, + { + "address": "0x140007e72", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x128" + }, + { + "address": "0x140007e79", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x291c0]" + }, + { + "address": "0x140007e80", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x140007e83", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x10], rax" + }, + { + "address": "0x140007e87", + "size": 7, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rbp + 0x90]" + }, + { + "address": "0x140007e8e", + "size": 3, + "mnemonic": "mov", + "operands": "r12, rdx" + }, + { + "address": "0x140007e91", + "size": 7, + "mnemonic": "mov", + "operands": "r13, qword ptr [rbp + 0xa8]" + }, + { + "address": "0x140007e98", + "size": 3, + "mnemonic": "mov", + "operands": "r15, r8" + }, + { + "address": "0x140007e9b", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x68], r8" + }, + { + "address": "0x140007ea0", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x140007ea3", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x78], rdx" + }, + { + "address": "0x140007ea8", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rsi" + }, + { + "address": "0x140007eab", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r12" + }, + { + "address": "0x140007eae", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x78], r13" + }, + { + "address": "0x140007eb2", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r9" + }, + { + "address": "0x140007eb5", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x60], 0" + }, + { + "address": "0x140007eba", + "size": 3, + "mnemonic": "mov", + "operands": "r14, r9" + }, + { + "address": "0x140007ebd", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a25c" + }, + { + "address": "0x140007ec2", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x64], eax" + }, + { + "address": "0x140007ec6", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, eax" + }, + { + "address": "0x140007ec8", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, -1" + }, + { + "address": "0x140007ecb", + "size": 6, + "mnemonic": "jl", + "operands": "0x140008349" + } + ], + "successors": [ + "0x140008349", + "0x140007ed1" + ] + }, + { + "address": "0x140008349", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008349", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x14000834e", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140007ed1", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007ed1", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, dword ptr [rsi + 4]" + }, + { + "address": "0x140007ed4", + "size": 6, + "mnemonic": "jge", + "operands": "0x140008349" + }, + { + "address": "0x140007eda", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rdi], 0xe06d7363" + }, + { + "address": "0x140007ee0", + "size": 6, + "mnemonic": "jne", + "operands": "0x140007fc8" + }, + { + "address": "0x140007ee6", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rdi + 0x18], 4" + }, + { + "address": "0x140007eea", + "size": 6, + "mnemonic": "jne", + "operands": "0x140007fc8" + }, + { + "address": "0x140007ef0", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdi + 0x20]" + }, + { + "address": "0x140007ef3", + "size": 5, + "mnemonic": "cmp", + "operands": "eax, 0x19930520" + }, + { + "address": "0x140007ef8", + "size": 2, + "mnemonic": "je", + "operands": "0x140007f08" + } + ], + "successors": [ + "0x140007f08", + "0x140007efa" + ] + }, + { + "address": "0x140007f08", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007f08", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rdi + 0x30], 0" + }, + { + "address": "0x140007f0d", + "size": 6, + "mnemonic": "jne", + "operands": "0x140007fc8" + }, + { + "address": "0x140007f13", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140007f18", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rax + 0x20], 0" + }, + { + "address": "0x140007f1d", + "size": 6, + "mnemonic": "je", + "operands": "0x1400082e2" + } + ], + "successors": [ + "0x1400082e2", + "0x140007f23" + ] + }, + { + "address": "0x140007efa", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007efa", + "size": 5, + "mnemonic": "add", + "operands": "eax, 0xe66cfadf" + }, + { + "address": "0x140007eff", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x140007f02", + "size": 6, + "mnemonic": "ja", + "operands": "0x140007fc8" + } + ], + "successors": [ + "0x140007fc8", + "0x140007f08" + ] + }, + { + "address": "0x1400082e2", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400082e2", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x10]" + }, + { + "address": "0x1400082e6", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x1400082e9", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x1400082ee", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0x128" + }, + { + "address": "0x1400082f5", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x1400082f7", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x1400082f9", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x1400082fb", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x1400082fd", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400082fe", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x1400082ff", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140008300", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140008301", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140007f23", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007f23", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140007f28", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rax + 0x20]" + }, + { + "address": "0x140007f2c", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140007f31", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdi + 0x38]" + }, + { + "address": "0x140007f35", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x60], 1" + }, + { + "address": "0x140007f3a", + "size": 4, + "mnemonic": "mov", + "operands": "r15, qword ptr [rax + 0x28]" + }, + { + "address": "0x140007f3e", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x68], r15" + }, + { + "address": "0x140007f43", + "size": 5, + "mnemonic": "call", + "operands": "0x140006de8" + }, + { + "address": "0x140007f48", + "size": 3, + "mnemonic": "test", + "operands": "rdi, rdi" + }, + { + "address": "0x140007f4b", + "size": 6, + "mnemonic": "je", + "operands": "0x140008349" + } + ], + "successors": [ + "0x140008349", + "0x140007f51" + ] + }, + { + "address": "0x140007fc8", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007fc8", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [r14 + 8]" + }, + { + "address": "0x140007fcc", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x40], rax" + }, + { + "address": "0x140007fd0", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x48], rsi" + }, + { + "address": "0x140007fd4", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rdi], 0xe06d7363" + }, + { + "address": "0x140007fda", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000829a" + }, + { + "address": "0x140007fe0", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rdi + 0x18], 4" + }, + { + "address": "0x140007fe4", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000829a" + }, + { + "address": "0x140007fea", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdi + 0x20]" + }, + { + "address": "0x140007fed", + "size": 5, + "mnemonic": "cmp", + "operands": "eax, 0x19930520" + }, + { + "address": "0x140007ff2", + "size": 2, + "mnemonic": "je", + "operands": "0x140008002" + } + ], + "successors": [ + "0x140008002", + "0x140007ff4" + ] + }, + { + "address": "0x140007f51", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007f51", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rdi], 0xe06d7363" + }, + { + "address": "0x140007f57", + "size": 2, + "mnemonic": "jne", + "operands": "0x140007f7e" + }, + { + "address": "0x140007f59", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rdi + 0x18], 4" + }, + { + "address": "0x140007f5d", + "size": 2, + "mnemonic": "jne", + "operands": "0x140007f7e" + }, + { + "address": "0x140007f5f", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdi + 0x20]" + }, + { + "address": "0x140007f62", + "size": 5, + "mnemonic": "cmp", + "operands": "eax, 0x19930520" + }, + { + "address": "0x140007f67", + "size": 2, + "mnemonic": "je", + "operands": "0x140007f73" + } + ], + "successors": [ + "0x140007f73", + "0x140007f69" + ] + }, + { + "address": "0x140008002", + "size": 34, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008002", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rsi + 0xc], 0" + }, + { + "address": "0x140008006", + "size": 6, + "mnemonic": "jbe", + "operands": "0x1400081d2" + }, + { + "address": "0x14000800c", + "size": 6, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbp + 0xa0]" + }, + { + "address": "0x140008012", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x48]" + }, + { + "address": "0x140008016", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], eax" + }, + { + "address": "0x14000801a", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x28]" + }, + { + "address": "0x14000801e", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r14" + }, + { + "address": "0x140008021", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rsi" + }, + { + "address": "0x140008026", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, ebx" + }, + { + "address": "0x140008029", + "size": 5, + "mnemonic": "call", + "operands": "0x140006650" + }, + { + "address": "0x14000802e", + "size": 4, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rbp - 0x28]" + }, + { + "address": "0x140008032", + "size": 4, + "mnemonic": "movdqa", + "operands": "xmm0, xmm1" + }, + { + "address": "0x140008036", + "size": 5, + "mnemonic": "psrldq", + "operands": "xmm0, 8" + }, + { + "address": "0x14000803b", + "size": 4, + "mnemonic": "movd", + "operands": "eax, xmm0" + }, + { + "address": "0x14000803f", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp - 0x38], xmm1" + }, + { + "address": "0x140008044", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, dword ptr [rbp - 0x10]" + }, + { + "address": "0x140008047", + "size": 6, + "mnemonic": "jae", + "operands": "0x1400081d2" + }, + { + "address": "0x14000804d", + "size": 4, + "mnemonic": "mov", + "operands": "r15d, dword ptr [rbp - 0x30]" + }, + { + "address": "0x140008051", + "size": 5, + "mnemonic": "movq", + "operands": "r9, xmm1" + }, + { + "address": "0x140008056", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x80], r9" + }, + { + "address": "0x14000805a", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp - 0x38]" + }, + { + "address": "0x14000805e", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax]" + }, + { + "address": "0x140008061", + "size": 4, + "mnemonic": "movsxd", + "operands": "rdx, dword ptr [rax + 0x10]" + }, + { + "address": "0x140008065", + "size": 3, + "mnemonic": "mov", + "operands": "eax, r15d" + }, + { + "address": "0x140008068", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + rax*4]" + }, + { + "address": "0x14000806c", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [r9 + 8]" + }, + { + "address": "0x140008070", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rdx + rcx*4]" + }, + { + "address": "0x140008074", + "size": 5, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [r8 + rax]" + }, + { + "address": "0x140008079", + "size": 5, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [r8 + rax + 0x10]" + }, + { + "address": "0x14000807e", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x50], ecx" + }, + { + "address": "0x140008081", + "size": 4, + "mnemonic": "movd", + "operands": "eax, xmm0" + }, + { + "address": "0x140008085", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rbp - 0x60], xmm0" + }, + { + "address": "0x140008089", + "size": 2, + "mnemonic": "cmp", + "operands": "eax, ebx" + }, + { + "address": "0x14000808b", + "size": 6, + "mnemonic": "jg", + "operands": "0x1400081c5" + } + ], + "successors": [ + "0x1400081c5", + "0x140008091" + ] + }, + { + "address": "0x140007ff4", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007ff4", + "size": 5, + "mnemonic": "add", + "operands": "eax, 0xe66cfadf" + }, + { + "address": "0x140007ff9", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x140007ffc", + "size": 6, + "mnemonic": "ja", + "operands": "0x14000829a" + } + ], + "successors": [ + "0x14000829a", + "0x140008002" + ] + }, + { + "address": "0x140007f73", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007f73", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rdi + 0x30], 0" + }, + { + "address": "0x140007f78", + "size": 6, + "mnemonic": "je", + "operands": "0x140008349" + } + ], + "successors": [ + "0x140008349", + "0x140007f7e" + ] + }, + { + "address": "0x140007f69", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007f69", + "size": 5, + "mnemonic": "add", + "operands": "eax, 0xe66cfadf" + }, + { + "address": "0x140007f6e", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x140007f71", + "size": 2, + "mnemonic": "ja", + "operands": "0x140007f7e" + } + ], + "successors": [ + "0x140007f7e", + "0x140007f73" + ] + }, + { + "address": "0x1400081c5", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400081c5", + "size": 3, + "mnemonic": "inc", + "operands": "r15d" + }, + { + "address": "0x1400081c8", + "size": 4, + "mnemonic": "cmp", + "operands": "r15d, dword ptr [rbp - 0x10]" + }, + { + "address": "0x1400081cc", + "size": 6, + "mnemonic": "jb", + "operands": "0x14000805a" + } + ], + "successors": [ + "0x14000805a", + "0x1400081d2" + ] + }, + { + "address": "0x140008091", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008091", + "size": 5, + "mnemonic": "movq", + "operands": "rax, xmm0" + }, + { + "address": "0x140008096", + "size": 4, + "mnemonic": "shr", + "operands": "rax, 0x20" + }, + { + "address": "0x14000809a", + "size": 2, + "mnemonic": "cmp", + "operands": "ebx, eax" + }, + { + "address": "0x14000809c", + "size": 6, + "mnemonic": "jg", + "operands": "0x1400081c5" + } + ], + "successors": [ + "0x1400081c5", + "0x1400080a2" + ] + }, + { + "address": "0x14000829a", + "size": 30, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000829a", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rsi + 0xc], 0" + }, + { + "address": "0x14000829e", + "size": 2, + "mnemonic": "jbe", + "operands": "0x1400082d6" + }, + { + "address": "0x1400082a0", + "size": 7, + "mnemonic": "cmp", + "operands": "byte ptr [rbp + 0x98], 0" + }, + { + "address": "0x1400082a7", + "size": 6, + "mnemonic": "jne", + "operands": "0x140008349" + }, + { + "address": "0x1400082ad", + "size": 6, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbp + 0xa0]" + }, + { + "address": "0x1400082b3", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r14" + }, + { + "address": "0x1400082b6", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], r13" + }, + { + "address": "0x1400082bb", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r15" + }, + { + "address": "0x1400082be", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x30], eax" + }, + { + "address": "0x1400082c2", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r12" + }, + { + "address": "0x1400082c5", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], ebx" + }, + { + "address": "0x1400082c9", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x1400082cc", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rsi" + }, + { + "address": "0x1400082d1", + "size": 5, + "mnemonic": "call", + "operands": "0x140008888" + }, + { + "address": "0x1400082d6", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x1400082db", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rax + 0x38], 0" + }, + { + "address": "0x1400082e0", + "size": 2, + "mnemonic": "jne", + "operands": "0x140008349" + }, + { + "address": "0x1400082e2", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x10]" + }, + { + "address": "0x1400082e6", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x1400082e9", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x1400082ee", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0x128" + }, + { + "address": "0x1400082f5", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x1400082f7", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x1400082f9", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x1400082fb", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x1400082fd", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400082fe", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x1400082ff", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140008300", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140008301", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140007f7e", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007f7e", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140007f83", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rax + 0x38], 0" + }, + { + "address": "0x140007f88", + "size": 2, + "mnemonic": "je", + "operands": "0x140007fc8" + } + ], + "successors": [ + "0x140007fc8", + "0x140007f8a" + ] + }, + { + "address": "0x14000805a", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000805a", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp - 0x38]" + }, + { + "address": "0x14000805e", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax]" + }, + { + "address": "0x140008061", + "size": 4, + "mnemonic": "movsxd", + "operands": "rdx, dword ptr [rax + 0x10]" + }, + { + "address": "0x140008065", + "size": 3, + "mnemonic": "mov", + "operands": "eax, r15d" + }, + { + "address": "0x140008068", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + rax*4]" + }, + { + "address": "0x14000806c", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [r9 + 8]" + }, + { + "address": "0x140008070", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rdx + rcx*4]" + }, + { + "address": "0x140008074", + "size": 5, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [r8 + rax]" + }, + { + "address": "0x140008079", + "size": 5, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [r8 + rax + 0x10]" + }, + { + "address": "0x14000807e", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x50], ecx" + }, + { + "address": "0x140008081", + "size": 4, + "mnemonic": "movd", + "operands": "eax, xmm0" + }, + { + "address": "0x140008085", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rbp - 0x60], xmm0" + }, + { + "address": "0x140008089", + "size": 2, + "mnemonic": "cmp", + "operands": "eax, ebx" + }, + { + "address": "0x14000808b", + "size": 6, + "mnemonic": "jg", + "operands": "0x1400081c5" + } + ], + "successors": [ + "0x1400081c5", + "0x140008091" + ] + }, + { + "address": "0x1400081d2", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400081d2", + "size": 2, + "mnemonic": "mov", + "operands": "eax, dword ptr [rsi]" + }, + { + "address": "0x1400081d4", + "size": 5, + "mnemonic": "and", + "operands": "eax, 0x1fffffff" + }, + { + "address": "0x1400081d9", + "size": 5, + "mnemonic": "cmp", + "operands": "eax, 0x19930521" + }, + { + "address": "0x1400081de", + "size": 6, + "mnemonic": "jb", + "operands": "0x1400082d6" + } + ], + "successors": [ + "0x1400082d6", + "0x1400081e4" + ] + }, + { + "address": "0x1400080a2", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400080a2", + "size": 4, + "mnemonic": "add", + "operands": "rcx, qword ptr [r14 + 8]" + }, + { + "address": "0x1400080a6", + "size": 3, + "mnemonic": "xor", + "operands": "r12d, r12d" + }, + { + "address": "0x1400080a9", + "size": 5, + "mnemonic": "psrldq", + "operands": "xmm0, 8" + }, + { + "address": "0x1400080ae", + "size": 5, + "mnemonic": "movq", + "operands": "rax, xmm0" + }, + { + "address": "0x1400080b3", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x68], rcx" + }, + { + "address": "0x1400080b7", + "size": 4, + "mnemonic": "shr", + "operands": "rax, 0x20" + }, + { + "address": "0x1400080bb", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x70], rax" + }, + { + "address": "0x1400080bf", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x1400080c1", + "size": 6, + "mnemonic": "je", + "operands": "0x1400081c0" + } + ], + "successors": [ + "0x1400081c0", + "0x1400080c7" + ] + }, + { + "address": "0x140007f8a", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007f8a", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140007f8f", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rax + 0x38]" + }, + { + "address": "0x140007f93", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140007f98", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x140007f9b", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140007f9e", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x38], 0" + }, + { + "address": "0x140007fa6", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a2f4" + }, + { + "address": "0x140007fab", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x140007fad", + "size": 2, + "mnemonic": "jne", + "operands": "0x140007fc4" + }, + { + "address": "0x140007faf", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140007fb2", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a3dc" + }, + { + "address": "0x140007fb7", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x140007fb9", + "size": 6, + "mnemonic": "je", + "operands": "0x140008326" + } + ], + "successors": [ + "0x140008326", + "0x140007fbf" + ] + }, + { + "address": "0x1400082d6", + "size": 16, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400082d6", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x1400082db", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rax + 0x38], 0" + }, + { + "address": "0x1400082e0", + "size": 2, + "mnemonic": "jne", + "operands": "0x140008349" + }, + { + "address": "0x1400082e2", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x10]" + }, + { + "address": "0x1400082e6", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x1400082e9", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x1400082ee", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0x128" + }, + { + "address": "0x1400082f5", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x1400082f7", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x1400082f9", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x1400082fb", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x1400082fd", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400082fe", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x1400082ff", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140008300", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140008301", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400081e4", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400081e4", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rsi + 0x20]" + }, + { + "address": "0x1400081e8", + "size": 2, + "mnemonic": "test", + "operands": "ebx, ebx" + }, + { + "address": "0x1400081ea", + "size": 2, + "mnemonic": "je", + "operands": "0x1400081f6" + } + ], + "successors": [ + "0x1400081f6", + "0x1400081ec" + ] + }, + { + "address": "0x1400081c0", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400081c0", + "size": 5, + "mnemonic": "mov", + "operands": "r12, qword ptr [rsp + 0x78]" + }, + { + "address": "0x1400081c5", + "size": 3, + "mnemonic": "inc", + "operands": "r15d" + }, + { + "address": "0x1400081c8", + "size": 4, + "mnemonic": "cmp", + "operands": "r15d, dword ptr [rbp - 0x10]" + }, + { + "address": "0x1400081cc", + "size": 6, + "mnemonic": "jb", + "operands": "0x14000805a" + } + ], + "successors": [ + "0x14000805a", + "0x1400081d2" + ] + }, + { + "address": "0x1400080c7", + "size": 33, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400080c7", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r12 + r12*4]" + }, + { + "address": "0x1400080cb", + "size": 4, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rcx + rax*4]" + }, + { + "address": "0x1400080cf", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rbp - 8], xmm0" + }, + { + "address": "0x1400080d3", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [rcx + rax*4 + 0x10]" + }, + { + "address": "0x1400080d7", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp + 8], eax" + }, + { + "address": "0x1400080da", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdi + 0x30]" + }, + { + "address": "0x1400080de", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rax + 0xc]" + }, + { + "address": "0x1400080e2", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x1400080e7", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + 4]" + }, + { + "address": "0x1400080eb", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdi + 0x30]" + }, + { + "address": "0x1400080ef", + "size": 3, + "mnemonic": "add", + "operands": "rcx, rbx" + }, + { + "address": "0x1400080f2", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x70], rcx" + }, + { + "address": "0x1400080f7", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rax + 0xc]" + }, + { + "address": "0x1400080fb", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x140008100", + "size": 4, + "mnemonic": "mov", + "operands": "r13d, dword ptr [rax + rbx]" + }, + { + "address": "0x140008104", + "size": 3, + "mnemonic": "test", + "operands": "r13d, r13d" + }, + { + "address": "0x140008107", + "size": 2, + "mnemonic": "jle", + "operands": "0x140008143" + }, + { + "address": "0x140008109", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x70]" + }, + { + "address": "0x14000810e", + "size": 3, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rax]" + }, + { + "address": "0x140008111", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x140008116", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [rdi + 0x30]" + }, + { + "address": "0x14000811a", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 8]" + }, + { + "address": "0x14000811e", + "size": 3, + "mnemonic": "add", + "operands": "rbx, rax" + }, + { + "address": "0x140008121", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x140008124", + "size": 5, + "mnemonic": "call", + "operands": "0x140008df4" + }, + { + "address": "0x140008129", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000812b", + "size": 2, + "mnemonic": "jne", + "operands": "0x140008155" + }, + { + "address": "0x14000812d", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140008132", + "size": 3, + "mnemonic": "dec", + "operands": "r13d" + }, + { + "address": "0x140008135", + "size": 4, + "mnemonic": "add", + "operands": "rax, 4" + }, + { + "address": "0x140008139", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x70], rax" + }, + { + "address": "0x14000813e", + "size": 3, + "mnemonic": "test", + "operands": "r13d, r13d" + }, + { + "address": "0x140008141", + "size": 2, + "mnemonic": "jg", + "operands": "0x14000810e" + } + ], + "successors": [ + "0x14000810e", + "0x140008143" + ] + }, + { + "address": "0x140008326", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008326", + "size": 5, + "mnemonic": "call", + "operands": "0x140010b70" + }, + { + "address": "0x14000832b", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140007fbf", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007fbf", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140008302" + } + ], + "successors": [ + "0x140008302" + ] + }, + { + "address": "0x1400081f6", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400081f6", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [rsi + 0x24], 4" + }, + { + "address": "0x1400081fa", + "size": 6, + "mnemonic": "je", + "operands": "0x1400082d6" + } + ], + "successors": [ + "0x1400082d6", + "0x140008200" + ] + }, + { + "address": "0x1400081ec", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400081ec", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x1400081f1", + "size": 3, + "mnemonic": "add", + "operands": "rax, rbx" + }, + { + "address": "0x1400081f4", + "size": 2, + "mnemonic": "jne", + "operands": "0x140008213" + }, + { + "address": "0x1400081f6", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [rsi + 0x24], 4" + }, + { + "address": "0x1400081fa", + "size": 6, + "mnemonic": "je", + "operands": "0x1400082d6" + } + ], + "successors": [ + "0x1400082d6", + "0x140008200" + ] + }, + { + "address": "0x14000810e", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000810e", + "size": 3, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rax]" + }, + { + "address": "0x140008111", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x140008116", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [rdi + 0x30]" + }, + { + "address": "0x14000811a", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 8]" + }, + { + "address": "0x14000811e", + "size": 3, + "mnemonic": "add", + "operands": "rbx, rax" + }, + { + "address": "0x140008121", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x140008124", + "size": 5, + "mnemonic": "call", + "operands": "0x140008df4" + }, + { + "address": "0x140008129", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000812b", + "size": 2, + "mnemonic": "jne", + "operands": "0x140008155" + }, + { + "address": "0x14000812d", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140008132", + "size": 3, + "mnemonic": "dec", + "operands": "r13d" + }, + { + "address": "0x140008135", + "size": 4, + "mnemonic": "add", + "operands": "rax, 4" + }, + { + "address": "0x140008139", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x70], rax" + }, + { + "address": "0x14000813e", + "size": 3, + "mnemonic": "test", + "operands": "r13d, r13d" + }, + { + "address": "0x140008141", + "size": 2, + "mnemonic": "jg", + "operands": "0x14000810e" + } + ], + "successors": [ + "0x14000810e", + "0x140008143" + ] + }, + { + "address": "0x140008143", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008143", + "size": 3, + "mnemonic": "inc", + "operands": "r12d" + }, + { + "address": "0x140008146", + "size": 4, + "mnemonic": "cmp", + "operands": "r12d, dword ptr [rbp - 0x70]" + }, + { + "address": "0x14000814a", + "size": 2, + "mnemonic": "je", + "operands": "0x1400081b8" + } + ], + "successors": [ + "0x1400081b8", + "0x14000814c" + ] + }, + { + "address": "0x140008302", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008302", + "size": 2, + "mnemonic": "mov", + "operands": "dl, 1" + }, + { + "address": "0x140008304", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140008307", + "size": 5, + "mnemonic": "call", + "operands": "0x140006f98" + }, + { + "address": "0x14000830c", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x60]" + }, + { + "address": "0x140008310", + "size": 5, + "mnemonic": "call", + "operands": "0x140009724" + }, + { + "address": "0x140008315", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x27c54]" + }, + { + "address": "0x14000831c", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x60]" + }, + { + "address": "0x140008320", + "size": 5, + "mnemonic": "call", + "operands": "0x140006198" + }, + { + "address": "0x140008325", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140008200", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008200", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x140008203", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r14" + }, + { + "address": "0x140008206", + "size": 5, + "mnemonic": "call", + "operands": "0x140006478" + }, + { + "address": "0x14000820b", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x14000820d", + "size": 6, + "mnemonic": "jne", + "operands": "0x1400082d6" + }, + { + "address": "0x140008213", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [rsi + 0x24], 4" + }, + { + "address": "0x140008217", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000832c" + }, + { + "address": "0x14000821d", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rsi + 0x20]" + }, + { + "address": "0x140008221", + "size": 2, + "mnemonic": "test", + "operands": "ebx, ebx" + }, + { + "address": "0x140008223", + "size": 2, + "mnemonic": "je", + "operands": "0x140008230" + } + ], + "successors": [ + "0x140008230", + "0x140008225" + ] + }, + { + "address": "0x1400081b8", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400081b8", + "size": 4, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rsp + 0x64]" + }, + { + "address": "0x1400081bc", + "size": 4, + "mnemonic": "mov", + "operands": "r9, qword ptr [rbp - 0x80]" + }, + { + "address": "0x1400081c0", + "size": 5, + "mnemonic": "mov", + "operands": "r12, qword ptr [rsp + 0x78]" + }, + { + "address": "0x1400081c5", + "size": 3, + "mnemonic": "inc", + "operands": "r15d" + }, + { + "address": "0x1400081c8", + "size": 4, + "mnemonic": "cmp", + "operands": "r15d, dword ptr [rbp - 0x10]" + }, + { + "address": "0x1400081cc", + "size": 6, + "mnemonic": "jb", + "operands": "0x14000805a" + } + ], + "successors": [ + "0x14000805a", + "0x1400081d2" + ] + }, + { + "address": "0x14000814c", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000814c", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x68]" + }, + { + "address": "0x140008150", + "size": 5, + "mnemonic": "jmp", + "operands": "0x1400080c7" + } + ], + "successors": [ + "0x1400080c7" + ] + }, + { + "address": "0x140008230", + "size": 25, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008230", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140008232", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140008235", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a2f4" + }, + { + "address": "0x14000823a", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x14000823c", + "size": 6, + "mnemonic": "jne", + "operands": "0x1400082d6" + }, + { + "address": "0x140008242", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp - 0x78]" + }, + { + "address": "0x140008246", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rsi" + }, + { + "address": "0x140008249", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r14" + }, + { + "address": "0x14000824c", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r12" + }, + { + "address": "0x14000824f", + "size": 5, + "mnemonic": "call", + "operands": "0x140006544" + }, + { + "address": "0x140008254", + "size": 6, + "mnemonic": "mov", + "operands": "cl, byte ptr [rbp + 0x98]" + }, + { + "address": "0x14000825a", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rax" + }, + { + "address": "0x14000825d", + "size": 5, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsp + 0x68]" + }, + { + "address": "0x140008262", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rdi" + }, + { + "address": "0x140008265", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x50], cl" + }, + { + "address": "0x140008269", + "size": 3, + "mnemonic": "or", + "operands": "ecx, 0xffffffff" + }, + { + "address": "0x14000826c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x48], r14" + }, + { + "address": "0x140008271", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x40], 0" + }, + { + "address": "0x14000827a", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x38], ecx" + }, + { + "address": "0x14000827e", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x30], ecx" + }, + { + "address": "0x140008282", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r12" + }, + { + "address": "0x140008285", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rsi" + }, + { + "address": "0x14000828a", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], 0" + }, + { + "address": "0x140008293", + "size": 5, + "mnemonic": "call", + "operands": "0x140006908" + }, + { + "address": "0x140008298", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400082d6" + } + ], + "successors": [ + "0x1400082d6" + ] + }, + { + "address": "0x140008225", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008225", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x14000822a", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbx + rax]" + }, + { + "address": "0x14000822e", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140008232" + } + ], + "successors": [ + "0x140008232" + ] + }, + { + "address": "0x140008232", + "size": 24, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008232", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140008235", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a2f4" + }, + { + "address": "0x14000823a", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x14000823c", + "size": 6, + "mnemonic": "jne", + "operands": "0x1400082d6" + }, + { + "address": "0x140008242", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp - 0x78]" + }, + { + "address": "0x140008246", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rsi" + }, + { + "address": "0x140008249", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r14" + }, + { + "address": "0x14000824c", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r12" + }, + { + "address": "0x14000824f", + "size": 5, + "mnemonic": "call", + "operands": "0x140006544" + }, + { + "address": "0x140008254", + "size": 6, + "mnemonic": "mov", + "operands": "cl, byte ptr [rbp + 0x98]" + }, + { + "address": "0x14000825a", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rax" + }, + { + "address": "0x14000825d", + "size": 5, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsp + 0x68]" + }, + { + "address": "0x140008262", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rdi" + }, + { + "address": "0x140008265", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x50], cl" + }, + { + "address": "0x140008269", + "size": 3, + "mnemonic": "or", + "operands": "ecx, 0xffffffff" + }, + { + "address": "0x14000826c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x48], r14" + }, + { + "address": "0x140008271", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x40], 0" + }, + { + "address": "0x14000827a", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x38], ecx" + }, + { + "address": "0x14000827e", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x30], ecx" + }, + { + "address": "0x140008282", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r12" + }, + { + "address": "0x140008285", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rsi" + }, + { + "address": "0x14000828a", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], 0" + }, + { + "address": "0x140008293", + "size": 5, + "mnemonic": "call", + "operands": "0x140006908" + }, + { + "address": "0x140008298", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400082d6" + } + ], + "successors": [ + "0x1400082d6" + ] + } + ] + }, + { + "address": "0x140008350", + "name": "", + "blocks": [ + { + "address": "0x140008350", + "size": 29, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008350", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140008352", + "size": 1, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140008353", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140008354", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140008355", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140008357", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140008359", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000835b", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14000835d", + "size": 8, + "mnemonic": "lea", + "operands": "rbp, [rsp - 0x88]" + }, + { + "address": "0x140008365", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x188" + }, + { + "address": "0x14000836c", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x28ccd]" + }, + { + "address": "0x140008373", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x140008376", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x70], rax" + }, + { + "address": "0x14000837a", + "size": 7, + "mnemonic": "mov", + "operands": "r15, qword ptr [rbp + 0xf0]" + }, + { + "address": "0x140008381", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r8" + }, + { + "address": "0x140008384", + "size": 7, + "mnemonic": "mov", + "operands": "r13, qword ptr [rbp + 0x108]" + }, + { + "address": "0x14000838b", + "size": 3, + "mnemonic": "mov", + "operands": "r12, rdx" + }, + { + "address": "0x14000838e", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x58], rdx" + }, + { + "address": "0x140008392", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x140008395", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r15" + }, + { + "address": "0x140008398", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x70], rbx" + }, + { + "address": "0x14000839d", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r9" + }, + { + "address": "0x1400083a0", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x60], r13" + }, + { + "address": "0x1400083a4", + "size": 3, + "mnemonic": "mov", + "operands": "r14, r9" + }, + { + "address": "0x1400083a7", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x60], 0" + }, + { + "address": "0x1400083ac", + "size": 5, + "mnemonic": "call", + "operands": "0x1400075e0" + }, + { + "address": "0x1400083b1", + "size": 5, + "mnemonic": "cmp", + "operands": "dword ptr [r14 + 0x48], 0" + }, + { + "address": "0x1400083b6", + "size": 2, + "mnemonic": "mov", + "operands": "esi, eax" + }, + { + "address": "0x1400083b8", + "size": 2, + "mnemonic": "je", + "operands": "0x1400083d2" + } + ], + "successors": [ + "0x1400083d2", + "0x1400083ba" + ] + }, + { + "address": "0x1400083d2", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400083d2", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x1400083d7", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rax + 0x78], -2" + }, + { + "address": "0x1400083db", + "size": 2, + "mnemonic": "je", + "operands": "0x1400083f1" + } + ], + "successors": [ + "0x1400083f1", + "0x1400083dd" + ] + }, + { + "address": "0x1400083ba", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400083ba", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x1400083bf", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rax + 0x78], -2" + }, + { + "address": "0x1400083c3", + "size": 6, + "mnemonic": "jne", + "operands": "0x140008881" + }, + { + "address": "0x1400083c9", + "size": 4, + "mnemonic": "mov", + "operands": "esi, dword ptr [r14 + 0x48]" + }, + { + "address": "0x1400083cd", + "size": 3, + "mnemonic": "sub", + "operands": "esi, 2" + }, + { + "address": "0x1400083d0", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400083f1" + } + ], + "successors": [ + "0x1400083f1" + ] + }, + { + "address": "0x1400083f1", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400083f1", + "size": 3, + "mnemonic": "cmp", + "operands": "esi, -1" + }, + { + "address": "0x1400083f4", + "size": 6, + "mnemonic": "jl", + "operands": "0x140008881" + } + ], + "successors": [ + "0x140008881", + "0x1400083fa" + ] + }, + { + "address": "0x1400083dd", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400083dd", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x1400083e2", + "size": 3, + "mnemonic": "mov", + "operands": "esi, dword ptr [rax + 0x78]" + }, + { + "address": "0x1400083e5", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x1400083ea", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x78], 0xfffffffe" + }, + { + "address": "0x1400083f1", + "size": 3, + "mnemonic": "cmp", + "operands": "esi, -1" + }, + { + "address": "0x1400083f4", + "size": 6, + "mnemonic": "jl", + "operands": "0x140008881" + } + ], + "successors": [ + "0x140008881", + "0x1400083fa" + ] + }, + { + "address": "0x140008881", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008881", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140008886", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400083fa", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400083fa", + "size": 5, + "mnemonic": "cmp", + "operands": "dword ptr [r15 + 8], 0" + }, + { + "address": "0x1400083ff", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip - 0x8406]" + }, + { + "address": "0x140008406", + "size": 2, + "mnemonic": "je", + "operands": "0x140008434" + } + ], + "successors": [ + "0x140008434", + "0x140008408" + ] + }, + { + "address": "0x140008434", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008434", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140008436", + "size": 2, + "mnemonic": "cmp", + "operands": "esi, eax" + }, + { + "address": "0x140008438", + "size": 6, + "mnemonic": "jge", + "operands": "0x140008881" + }, + { + "address": "0x14000843e", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rdi], 0xe06d7363" + }, + { + "address": "0x140008444", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000852d" + }, + { + "address": "0x14000844a", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rdi + 0x18], 4" + }, + { + "address": "0x14000844e", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000852d" + }, + { + "address": "0x140008454", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdi + 0x20]" + }, + { + "address": "0x140008457", + "size": 5, + "mnemonic": "cmp", + "operands": "eax, 0x19930520" + }, + { + "address": "0x14000845c", + "size": 2, + "mnemonic": "je", + "operands": "0x14000846c" + } + ], + "successors": [ + "0x14000846c", + "0x14000845e" + ] + }, + { + "address": "0x140008408", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008408", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [r15 + 8]" + }, + { + "address": "0x14000840c", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [r14 + 8]" + }, + { + "address": "0x140008410", + "size": 3, + "mnemonic": "add", + "operands": "rdx, rcx" + }, + { + "address": "0x140008413", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140008416", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140008419", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r8 + 0x23d90]" + }, + { + "address": "0x140008422", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r8 + 0x23da0]" + }, + { + "address": "0x14000842a", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, rax" + }, + { + "address": "0x14000842d", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x140008430", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140008432", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140008436" + } + ], + "successors": [ + "0x140008436" + ] + }, + { + "address": "0x14000846c", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000846c", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rdi + 0x30], 0" + }, + { + "address": "0x140008471", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000852d" + }, + { + "address": "0x140008477", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14000847c", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rax + 0x20], 0" + }, + { + "address": "0x140008481", + "size": 6, + "mnemonic": "je", + "operands": "0x14000881a" + } + ], + "successors": [ + "0x14000881a", + "0x140008487" + ] + }, + { + "address": "0x14000845e", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000845e", + "size": 5, + "mnemonic": "add", + "operands": "eax, 0xe66cfadf" + }, + { + "address": "0x140008463", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x140008466", + "size": 6, + "mnemonic": "ja", + "operands": "0x14000852d" + } + ], + "successors": [ + "0x14000852d", + "0x14000846c" + ] + }, + { + "address": "0x140008436", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008436", + "size": 2, + "mnemonic": "cmp", + "operands": "esi, eax" + }, + { + "address": "0x140008438", + "size": 6, + "mnemonic": "jge", + "operands": "0x140008881" + }, + { + "address": "0x14000843e", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rdi], 0xe06d7363" + }, + { + "address": "0x140008444", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000852d" + }, + { + "address": "0x14000844a", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rdi + 0x18], 4" + }, + { + "address": "0x14000844e", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000852d" + }, + { + "address": "0x140008454", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdi + 0x20]" + }, + { + "address": "0x140008457", + "size": 5, + "mnemonic": "cmp", + "operands": "eax, 0x19930520" + }, + { + "address": "0x14000845c", + "size": 2, + "mnemonic": "je", + "operands": "0x14000846c" + } + ], + "successors": [ + "0x14000846c", + "0x14000845e" + ] + }, + { + "address": "0x14000881a", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000881a", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x70]" + }, + { + "address": "0x14000881e", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x140008821", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140008826", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0x188" + }, + { + "address": "0x14000882d", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000882f", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140008831", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140008833", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140008835", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140008836", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140008837", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140008838", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140008839", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140008487", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008487", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14000848c", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rax + 0x20]" + }, + { + "address": "0x140008490", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140008495", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdi + 0x38]" + }, + { + "address": "0x140008499", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x60], 1" + }, + { + "address": "0x14000849e", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rax + 0x28]" + }, + { + "address": "0x1400084a2", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x70], rbx" + }, + { + "address": "0x1400084a7", + "size": 5, + "mnemonic": "call", + "operands": "0x140006de8" + }, + { + "address": "0x1400084ac", + "size": 3, + "mnemonic": "test", + "operands": "rdi, rdi" + }, + { + "address": "0x1400084af", + "size": 6, + "mnemonic": "je", + "operands": "0x140008881" + } + ], + "successors": [ + "0x140008881", + "0x1400084b5" + ] + }, + { + "address": "0x14000852d", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000852d", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [r14 + 8]" + }, + { + "address": "0x140008531", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 8]" + }, + { + "address": "0x140008535", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r15" + }, + { + "address": "0x140008538", + "size": 5, + "mnemonic": "call", + "operands": "0x140009604" + }, + { + "address": "0x14000853d", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rdi], 0xe06d7363" + }, + { + "address": "0x140008543", + "size": 6, + "mnemonic": "jne", + "operands": "0x1400087d2" + }, + { + "address": "0x140008549", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rdi + 0x18], 4" + }, + { + "address": "0x14000854d", + "size": 6, + "mnemonic": "jne", + "operands": "0x1400087d2" + }, + { + "address": "0x140008553", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdi + 0x20]" + }, + { + "address": "0x140008556", + "size": 5, + "mnemonic": "cmp", + "operands": "eax, 0x19930520" + }, + { + "address": "0x14000855b", + "size": 2, + "mnemonic": "je", + "operands": "0x14000856b" + } + ], + "successors": [ + "0x14000856b", + "0x14000855d" + ] + }, + { + "address": "0x1400084b5", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400084b5", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rdi], 0xe06d7363" + }, + { + "address": "0x1400084bb", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400084e2" + }, + { + "address": "0x1400084bd", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rdi + 0x18], 4" + }, + { + "address": "0x1400084c1", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400084e2" + }, + { + "address": "0x1400084c3", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdi + 0x20]" + }, + { + "address": "0x1400084c6", + "size": 5, + "mnemonic": "cmp", + "operands": "eax, 0x19930520" + }, + { + "address": "0x1400084cb", + "size": 2, + "mnemonic": "je", + "operands": "0x1400084d7" + } + ], + "successors": [ + "0x1400084d7", + "0x1400084cd" + ] + }, + { + "address": "0x14000856b", + "size": 27, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000856b", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rbp - 8], 0" + }, + { + "address": "0x14000856f", + "size": 6, + "mnemonic": "jbe", + "operands": "0x1400087b7" + }, + { + "address": "0x140008575", + "size": 6, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbp + 0x100]" + }, + { + "address": "0x14000857b", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 8]" + }, + { + "address": "0x14000857f", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], eax" + }, + { + "address": "0x140008583", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x50]" + }, + { + "address": "0x140008587", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r14" + }, + { + "address": "0x14000858a", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r15" + }, + { + "address": "0x14000858f", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, esi" + }, + { + "address": "0x140008592", + "size": 5, + "mnemonic": "call", + "operands": "0x140006788" + }, + { + "address": "0x140008597", + "size": 4, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rbp - 0x50]" + }, + { + "address": "0x14000859b", + "size": 4, + "mnemonic": "movdqa", + "operands": "xmm0, xmm1" + }, + { + "address": "0x14000859f", + "size": 5, + "mnemonic": "psrldq", + "operands": "xmm0, 8" + }, + { + "address": "0x1400085a4", + "size": 4, + "mnemonic": "movd", + "operands": "eax, xmm0" + }, + { + "address": "0x1400085a8", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp - 0x78], xmm1" + }, + { + "address": "0x1400085ad", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, dword ptr [rbp - 0x38]" + }, + { + "address": "0x1400085b0", + "size": 6, + "mnemonic": "jae", + "operands": "0x1400087b7" + }, + { + "address": "0x1400085b6", + "size": 4, + "mnemonic": "mov", + "operands": "r12d, dword ptr [rbp - 0x70]" + }, + { + "address": "0x1400085ba", + "size": 7, + "mnemonic": "lea", + "operands": "r11, [rip - 0x85c1]" + }, + { + "address": "0x1400085c1", + "size": 5, + "mnemonic": "movq", + "operands": "rbx, xmm1" + }, + { + "address": "0x1400085c6", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x64], r12d" + }, + { + "address": "0x1400085cb", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x80], rbx" + }, + { + "address": "0x1400085cf", + "size": 4, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rbx + 0x18]" + }, + { + "address": "0x1400085d3", + "size": 5, + "mnemonic": "movq", + "operands": "rax, xmm0" + }, + { + "address": "0x1400085d8", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rbp - 0x78], xmm0" + }, + { + "address": "0x1400085dc", + "size": 2, + "mnemonic": "cmp", + "operands": "eax, esi" + }, + { + "address": "0x1400085de", + "size": 6, + "mnemonic": "jg", + "operands": "0x140008710" + } + ], + "successors": [ + "0x140008710", + "0x1400085e4" + ] + }, + { + "address": "0x14000855d", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000855d", + "size": 5, + "mnemonic": "add", + "operands": "eax, 0xe66cfadf" + }, + { + "address": "0x140008562", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x140008565", + "size": 6, + "mnemonic": "ja", + "operands": "0x1400087d2" + } + ], + "successors": [ + "0x1400087d2", + "0x14000856b" + ] + }, + { + "address": "0x1400084d7", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400084d7", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rdi + 0x30], 0" + }, + { + "address": "0x1400084dc", + "size": 6, + "mnemonic": "je", + "operands": "0x140008881" + } + ], + "successors": [ + "0x140008881", + "0x1400084e2" + ] + }, + { + "address": "0x1400084cd", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400084cd", + "size": 5, + "mnemonic": "add", + "operands": "eax, 0xe66cfadf" + }, + { + "address": "0x1400084d2", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x1400084d5", + "size": 2, + "mnemonic": "ja", + "operands": "0x1400084e2" + } + ], + "successors": [ + "0x1400084e2", + "0x1400084d7" + ] + }, + { + "address": "0x140008710", + "size": 41, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008710", + "size": 4, + "mnemonic": "mov", + "operands": "r10, qword ptr [rbx + 8]" + }, + { + "address": "0x140008714", + "size": 3, + "mnemonic": "inc", + "operands": "r12d" + }, + { + "address": "0x140008717", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r10" + }, + { + "address": "0x14000871a", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x64], r12d" + }, + { + "address": "0x14000871f", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [r10]" + }, + { + "address": "0x140008723", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140008726", + "size": 9, + "mnemonic": "movsx", + "operands": "r9, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x14000872f", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140008737", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x14000873a", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x14000873d", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], rdx" + }, + { + "address": "0x140008741", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140008743", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 0x18], eax" + }, + { + "address": "0x140008746", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140008749", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r10" + }, + { + "address": "0x14000874c", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x14000874f", + "size": 9, + "mnemonic": "movsx", + "operands": "r8, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x140008758", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140008760", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r8" + }, + { + "address": "0x140008763", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x140008766", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x140008769", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x14000876b", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 0x1c], eax" + }, + { + "address": "0x14000876e", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], rdx" + }, + { + "address": "0x140008772", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140008775", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140008778", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x140008781", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140008789", + "size": 3, + "mnemonic": "sub", + "operands": "r10, rax" + }, + { + "address": "0x14000878c", + "size": 3, + "mnemonic": "sub", + "operands": "r10, r8" + }, + { + "address": "0x14000878f", + "size": 3, + "mnemonic": "sub", + "operands": "r10, r9" + }, + { + "address": "0x140008792", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r10 - 4]" + }, + { + "address": "0x140008796", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140008798", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 0x20], eax" + }, + { + "address": "0x14000879b", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r10 + 4]" + }, + { + "address": "0x14000879f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], r10" + }, + { + "address": "0x1400087a3", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [r10]" + }, + { + "address": "0x1400087a6", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], rax" + }, + { + "address": "0x1400087aa", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 0x24], ecx" + }, + { + "address": "0x1400087ad", + "size": 4, + "mnemonic": "cmp", + "operands": "r12d, dword ptr [rbp - 0x38]" + }, + { + "address": "0x1400087b1", + "size": 6, + "mnemonic": "jb", + "operands": "0x1400085cf" + } + ], + "successors": [ + "0x1400085cf", + "0x1400087b7" + ] + }, + { + "address": "0x1400085e4", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400085e4", + "size": 4, + "mnemonic": "shr", + "operands": "rax, 0x20" + }, + { + "address": "0x1400085e8", + "size": 2, + "mnemonic": "cmp", + "operands": "esi, eax" + }, + { + "address": "0x1400085ea", + "size": 6, + "mnemonic": "jg", + "operands": "0x140008710" + } + ], + "successors": [ + "0x140008710", + "0x1400085f0" + ] + }, + { + "address": "0x1400087d2", + "size": 30, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400087d2", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rbp - 8], 0" + }, + { + "address": "0x1400087d6", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14000880e" + }, + { + "address": "0x1400087d8", + "size": 7, + "mnemonic": "cmp", + "operands": "byte ptr [rbp + 0xf8], 0" + }, + { + "address": "0x1400087df", + "size": 6, + "mnemonic": "jne", + "operands": "0x140008881" + }, + { + "address": "0x1400087e5", + "size": 6, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbp + 0x100]" + }, + { + "address": "0x1400087eb", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r14" + }, + { + "address": "0x1400087ee", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], r13" + }, + { + "address": "0x1400087f3", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rbx" + }, + { + "address": "0x1400087f6", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x30], eax" + }, + { + "address": "0x1400087fa", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r12" + }, + { + "address": "0x1400087fd", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], esi" + }, + { + "address": "0x140008801", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140008804", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r15" + }, + { + "address": "0x140008809", + "size": 5, + "mnemonic": "call", + "operands": "0x140008aec" + }, + { + "address": "0x14000880e", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140008813", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rax + 0x38], 0" + }, + { + "address": "0x140008818", + "size": 2, + "mnemonic": "jne", + "operands": "0x140008881" + }, + { + "address": "0x14000881a", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x70]" + }, + { + "address": "0x14000881e", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x140008821", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140008826", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0x188" + }, + { + "address": "0x14000882d", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000882f", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140008831", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140008833", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140008835", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140008836", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140008837", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140008838", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140008839", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400084e2", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400084e2", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x1400084e7", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rax + 0x38], 0" + }, + { + "address": "0x1400084ec", + "size": 2, + "mnemonic": "je", + "operands": "0x14000852d" + } + ], + "successors": [ + "0x14000852d", + "0x1400084ee" + ] + }, + { + "address": "0x1400085cf", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400085cf", + "size": 4, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rbx + 0x18]" + }, + { + "address": "0x1400085d3", + "size": 5, + "mnemonic": "movq", + "operands": "rax, xmm0" + }, + { + "address": "0x1400085d8", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rbp - 0x78], xmm0" + }, + { + "address": "0x1400085dc", + "size": 2, + "mnemonic": "cmp", + "operands": "eax, esi" + }, + { + "address": "0x1400085de", + "size": 6, + "mnemonic": "jg", + "operands": "0x140008710" + } + ], + "successors": [ + "0x140008710", + "0x1400085e4" + ] + }, + { + "address": "0x1400087b7", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400087b7", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [r15], 0x40" + }, + { + "address": "0x1400087bb", + "size": 2, + "mnemonic": "je", + "operands": "0x14000880e" + } + ], + "successors": [ + "0x14000880e", + "0x1400087bd" + ] + }, + { + "address": "0x1400085f0", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400085f0", + "size": 4, + "mnemonic": "mov", + "operands": "r9, qword ptr [r14 + 0x10]" + }, + { + "address": "0x1400085f4", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x78]" + }, + { + "address": "0x1400085f8", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [r14 + 8]" + }, + { + "address": "0x1400085fc", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x20]" + }, + { + "address": "0x140008600", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, dword ptr [r9]" + }, + { + "address": "0x140008603", + "size": 5, + "mnemonic": "call", + "operands": "0x140009580" + }, + { + "address": "0x140008608", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbp + 0x20]" + }, + { + "address": "0x14000860b", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x68], 0" + }, + { + "address": "0x140008613", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x78], eax" + }, + { + "address": "0x140008617", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140008619", + "size": 6, + "mnemonic": "je", + "operands": "0x140008709" + } + ], + "successors": [ + "0x140008709", + "0x14000861f" + ] + }, + { + "address": "0x1400084ee", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400084ee", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x1400084f3", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rax + 0x38]" + }, + { + "address": "0x1400084f7", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x1400084fc", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x1400084ff", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140008502", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x38], 0" + }, + { + "address": "0x14000850a", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a2f4" + }, + { + "address": "0x14000850f", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x140008511", + "size": 2, + "mnemonic": "jne", + "operands": "0x140008528" + }, + { + "address": "0x140008513", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140008516", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a3dc" + }, + { + "address": "0x14000851b", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x14000851d", + "size": 6, + "mnemonic": "je", + "operands": "0x14000885e" + } + ], + "successors": [ + "0x14000885e", + "0x140008523" + ] + }, + { + "address": "0x14000880e", + "size": 16, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000880e", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140008813", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rax + 0x38], 0" + }, + { + "address": "0x140008818", + "size": 2, + "mnemonic": "jne", + "operands": "0x140008881" + }, + { + "address": "0x14000881a", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x70]" + }, + { + "address": "0x14000881e", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x140008821", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140008826", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0x188" + }, + { + "address": "0x14000882d", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000882f", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140008831", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140008833", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140008835", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140008836", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140008837", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140008838", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140008839", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400087bd", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400087bd", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r15" + }, + { + "address": "0x1400087c0", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r14" + }, + { + "address": "0x1400087c3", + "size": 5, + "mnemonic": "call", + "operands": "0x1400064a4" + }, + { + "address": "0x1400087c8", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x1400087ca", + "size": 6, + "mnemonic": "je", + "operands": "0x140008864" + } + ], + "successors": [ + "0x140008864", + "0x1400087d0" + ] + }, + { + "address": "0x140008709", + "size": 42, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008709", + "size": 7, + "mnemonic": "lea", + "operands": "r11, [rip - 0x8710]" + }, + { + "address": "0x140008710", + "size": 4, + "mnemonic": "mov", + "operands": "r10, qword ptr [rbx + 8]" + }, + { + "address": "0x140008714", + "size": 3, + "mnemonic": "inc", + "operands": "r12d" + }, + { + "address": "0x140008717", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r10" + }, + { + "address": "0x14000871a", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x64], r12d" + }, + { + "address": "0x14000871f", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [r10]" + }, + { + "address": "0x140008723", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140008726", + "size": 9, + "mnemonic": "movsx", + "operands": "r9, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x14000872f", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140008737", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x14000873a", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x14000873d", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], rdx" + }, + { + "address": "0x140008741", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140008743", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 0x18], eax" + }, + { + "address": "0x140008746", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140008749", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r10" + }, + { + "address": "0x14000874c", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x14000874f", + "size": 9, + "mnemonic": "movsx", + "operands": "r8, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x140008758", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140008760", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r8" + }, + { + "address": "0x140008763", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x140008766", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x140008769", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x14000876b", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 0x1c], eax" + }, + { + "address": "0x14000876e", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], rdx" + }, + { + "address": "0x140008772", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140008775", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140008778", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x140008781", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140008789", + "size": 3, + "mnemonic": "sub", + "operands": "r10, rax" + }, + { + "address": "0x14000878c", + "size": 3, + "mnemonic": "sub", + "operands": "r10, r8" + }, + { + "address": "0x14000878f", + "size": 3, + "mnemonic": "sub", + "operands": "r10, r9" + }, + { + "address": "0x140008792", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r10 - 4]" + }, + { + "address": "0x140008796", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140008798", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 0x20], eax" + }, + { + "address": "0x14000879b", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r10 + 4]" + }, + { + "address": "0x14000879f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], r10" + }, + { + "address": "0x1400087a3", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [r10]" + }, + { + "address": "0x1400087a6", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], rax" + }, + { + "address": "0x1400087aa", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 0x24], ecx" + }, + { + "address": "0x1400087ad", + "size": 4, + "mnemonic": "cmp", + "operands": "r12d, dword ptr [rbp - 0x38]" + }, + { + "address": "0x1400087b1", + "size": 6, + "mnemonic": "jb", + "operands": "0x1400085cf" + } + ], + "successors": [ + "0x1400085cf", + "0x1400087b7" + ] + }, + { + "address": "0x14000861f", + "size": 16, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000861f", + "size": 4, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rbp + 0x38]" + }, + { + "address": "0x140008623", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdi + 0x30]" + }, + { + "address": "0x140008627", + "size": 4, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rbp + 0x48]" + }, + { + "address": "0x14000862b", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rbp - 0x30], xmm0" + }, + { + "address": "0x14000862f", + "size": 5, + "mnemonic": "movsd", + "operands": "xmm0, qword ptr [rbp + 0x58]" + }, + { + "address": "0x140008634", + "size": 5, + "mnemonic": "movsd", + "operands": "qword ptr [rbp - 0x10], xmm0" + }, + { + "address": "0x140008639", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rbp - 0x20], xmm1" + }, + { + "address": "0x14000863d", + "size": 4, + "mnemonic": "movsxd", + "operands": "r13, dword ptr [rax + 0xc]" + }, + { + "address": "0x140008641", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x140008646", + "size": 4, + "mnemonic": "add", + "operands": "rax, 4" + }, + { + "address": "0x14000864a", + "size": 3, + "mnemonic": "add", + "operands": "r13, rax" + }, + { + "address": "0x14000864d", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdi + 0x30]" + }, + { + "address": "0x140008651", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rax + 0xc]" + }, + { + "address": "0x140008655", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x14000865a", + "size": 4, + "mnemonic": "mov", + "operands": "r12d, dword ptr [rax + rbx]" + }, + { + "address": "0x14000865e", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140008687" + } + ], + "successors": [ + "0x140008687" + ] + }, + { + "address": "0x14000885e", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000885e", + "size": 5, + "mnemonic": "call", + "operands": "0x140010b70" + }, + { + "address": "0x140008863", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140008523", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008523", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000883a" + } + ], + "successors": [ + "0x14000883a" + ] + }, + { + "address": "0x140008864", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008864", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140008869", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x20], rdi" + }, + { + "address": "0x14000886d", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140008872", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140008877", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x28], rcx" + }, + { + "address": "0x14000887b", + "size": 5, + "mnemonic": "call", + "operands": "0x140010b70" + }, + { + "address": "0x140008880", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400087d0", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400087d0", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000880e" + } + ], + "successors": [ + "0x14000880e" + ] + }, + { + "address": "0x140008687", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008687", + "size": 3, + "mnemonic": "test", + "operands": "r12d, r12d" + }, + { + "address": "0x14000868a", + "size": 2, + "mnemonic": "jg", + "operands": "0x140008660" + } + ], + "successors": [ + "0x140008660", + "0x14000868c" + ] + }, + { + "address": "0x14000883a", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000883a", + "size": 2, + "mnemonic": "mov", + "operands": "dl, 1" + }, + { + "address": "0x14000883c", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x14000883f", + "size": 5, + "mnemonic": "call", + "operands": "0x140006f98" + }, + { + "address": "0x140008844", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x78]" + }, + { + "address": "0x140008848", + "size": 5, + "mnemonic": "call", + "operands": "0x140009724" + }, + { + "address": "0x14000884d", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x2771c]" + }, + { + "address": "0x140008854", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x78]" + }, + { + "address": "0x140008858", + "size": 5, + "mnemonic": "call", + "operands": "0x140006198" + }, + { + "address": "0x14000885d", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140008660", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008660", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [r13]" + }, + { + "address": "0x140008664", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x140008669", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [rdi + 0x30]" + }, + { + "address": "0x14000866d", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x30]" + }, + { + "address": "0x140008671", + "size": 3, + "mnemonic": "add", + "operands": "rbx, rax" + }, + { + "address": "0x140008674", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x140008677", + "size": 5, + "mnemonic": "call", + "operands": "0x140008f14" + }, + { + "address": "0x14000867c", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000867e", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400086ab" + }, + { + "address": "0x140008680", + "size": 3, + "mnemonic": "dec", + "operands": "r12d" + }, + { + "address": "0x140008683", + "size": 4, + "mnemonic": "add", + "operands": "r13, 4" + }, + { + "address": "0x140008687", + "size": 3, + "mnemonic": "test", + "operands": "r12d, r12d" + }, + { + "address": "0x14000868a", + "size": 2, + "mnemonic": "jg", + "operands": "0x140008660" + } + ], + "successors": [ + "0x140008660", + "0x14000868c" + ] + }, + { + "address": "0x14000868c", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000868c", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x20]" + }, + { + "address": "0x140008690", + "size": 5, + "mnemonic": "call", + "operands": "0x140009b74" + }, + { + "address": "0x140008695", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [rsp + 0x68]" + }, + { + "address": "0x140008699", + "size": 2, + "mnemonic": "inc", + "operands": "eax" + }, + { + "address": "0x14000869b", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x68], eax" + }, + { + "address": "0x14000869f", + "size": 4, + "mnemonic": "cmp", + "operands": "eax, dword ptr [rsp + 0x78]" + }, + { + "address": "0x1400086a3", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000861f" + }, + { + "address": "0x1400086a9", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140008700" + } + ], + "successors": [ + "0x140008700" + ] + }, + { + "address": "0x140008700", + "size": 44, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008700", + "size": 5, + "mnemonic": "mov", + "operands": "r12d, dword ptr [rsp + 0x64]" + }, + { + "address": "0x140008705", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rbp - 0x80]" + }, + { + "address": "0x140008709", + "size": 7, + "mnemonic": "lea", + "operands": "r11, [rip - 0x8710]" + }, + { + "address": "0x140008710", + "size": 4, + "mnemonic": "mov", + "operands": "r10, qword ptr [rbx + 8]" + }, + { + "address": "0x140008714", + "size": 3, + "mnemonic": "inc", + "operands": "r12d" + }, + { + "address": "0x140008717", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r10" + }, + { + "address": "0x14000871a", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x64], r12d" + }, + { + "address": "0x14000871f", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [r10]" + }, + { + "address": "0x140008723", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140008726", + "size": 9, + "mnemonic": "movsx", + "operands": "r9, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x14000872f", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140008737", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x14000873a", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x14000873d", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], rdx" + }, + { + "address": "0x140008741", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140008743", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 0x18], eax" + }, + { + "address": "0x140008746", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140008749", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r10" + }, + { + "address": "0x14000874c", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x14000874f", + "size": 9, + "mnemonic": "movsx", + "operands": "r8, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x140008758", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140008760", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r8" + }, + { + "address": "0x140008763", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x140008766", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x140008769", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x14000876b", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 0x1c], eax" + }, + { + "address": "0x14000876e", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], rdx" + }, + { + "address": "0x140008772", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140008775", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140008778", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x140008781", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140008789", + "size": 3, + "mnemonic": "sub", + "operands": "r10, rax" + }, + { + "address": "0x14000878c", + "size": 3, + "mnemonic": "sub", + "operands": "r10, r8" + }, + { + "address": "0x14000878f", + "size": 3, + "mnemonic": "sub", + "operands": "r10, r9" + }, + { + "address": "0x140008792", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r10 - 4]" + }, + { + "address": "0x140008796", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140008798", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 0x20], eax" + }, + { + "address": "0x14000879b", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r10 + 4]" + }, + { + "address": "0x14000879f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], r10" + }, + { + "address": "0x1400087a3", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [r10]" + }, + { + "address": "0x1400087a6", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], rax" + }, + { + "address": "0x1400087aa", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 0x24], ecx" + }, + { + "address": "0x1400087ad", + "size": 4, + "mnemonic": "cmp", + "operands": "r12d, dword ptr [rbp - 0x38]" + }, + { + "address": "0x1400087b1", + "size": 6, + "mnemonic": "jb", + "operands": "0x1400085cf" + } + ], + "successors": [ + "0x1400085cf", + "0x1400087b7" + ] + } + ] + }, + { + "address": "0x140008897", + "name": "", + "blocks": [ + { + "address": "0x140008897", + "size": 14, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008897", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140008898", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140008899", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000889a", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x14000889c", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x14000889e", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x1400088a0", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x1400088a2", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0xc0" + }, + { + "address": "0x1400088a9", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rcx], 0x80000003" + }, + { + "address": "0x1400088af", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, r9" + }, + { + "address": "0x1400088b2", + "size": 3, + "mnemonic": "mov", + "operands": "r15, r8" + }, + { + "address": "0x1400088b5", + "size": 3, + "mnemonic": "mov", + "operands": "r12, rdx" + }, + { + "address": "0x1400088b8", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rcx" + }, + { + "address": "0x1400088bb", + "size": 6, + "mnemonic": "je", + "operands": "0x140008ac8" + } + ], + "successors": [ + "0x140008ac8", + "0x1400088c1" + ] + }, + { + "address": "0x140008ac8", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140008ac8", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x118]" + }, + { + "address": "0x140008ad0", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0xc0" + }, + { + "address": "0x140008ad7", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140008ad9", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140008adb", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140008add", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140008adf", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140008ae0", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140008ae1", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140008ae2", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400088c1", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400088c1", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x1400088c6", + "size": 8, + "mnemonic": "mov", + "operands": "r13d, dword ptr [rsp + 0x130]" + }, + { + "address": "0x1400088ce", + "size": 8, + "mnemonic": "mov", + "operands": "r14d, dword ptr [rsp + 0x128]" + }, + { + "address": "0x1400088d6", + "size": 8, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x120]" + }, + { + "address": "0x1400088de", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rax + 0x10], 0" + }, + { + "address": "0x1400088e3", + "size": 2, + "mnemonic": "je", + "operands": "0x140008940" + } + ], + "successors": [ + "0x140008940", + "0x1400088e5" + ] + }, + { + "address": "0x140008940", + "size": 36, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008940", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 8]" + }, + { + "address": "0x140008944", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x68], rax" + }, + { + "address": "0x140008949", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x60], rdi" + }, + { + "address": "0x14000894e", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rdi + 0xc], 0" + }, + { + "address": "0x140008952", + "size": 6, + "mnemonic": "jbe", + "operands": "0x140008ae3" + }, + { + "address": "0x140008958", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], r13d" + }, + { + "address": "0x14000895d", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x60]" + }, + { + "address": "0x140008962", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rbp" + }, + { + "address": "0x140008965", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rdi" + }, + { + "address": "0x14000896a", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, r14d" + }, + { + "address": "0x14000896d", + "size": 8, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x98]" + }, + { + "address": "0x140008975", + "size": 5, + "mnemonic": "call", + "operands": "0x140006650" + }, + { + "address": "0x14000897a", + "size": 8, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rsp + 0x98]" + }, + { + "address": "0x140008982", + "size": 4, + "mnemonic": "movdqa", + "operands": "xmm0, xmm1" + }, + { + "address": "0x140008986", + "size": 5, + "mnemonic": "psrldq", + "operands": "xmm0, 8" + }, + { + "address": "0x14000898b", + "size": 4, + "mnemonic": "movd", + "operands": "eax, xmm0" + }, + { + "address": "0x14000898f", + "size": 6, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rsp + 0x70], xmm1" + }, + { + "address": "0x140008995", + "size": 7, + "mnemonic": "cmp", + "operands": "eax, dword ptr [rsp + 0xb0]" + }, + { + "address": "0x14000899c", + "size": 6, + "mnemonic": "jae", + "operands": "0x140008ac8" + }, + { + "address": "0x1400089a2", + "size": 4, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rsp + 0x78]" + }, + { + "address": "0x1400089a6", + "size": 5, + "mnemonic": "movq", + "operands": "r9, xmm1" + }, + { + "address": "0x1400089ab", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x100], r9" + }, + { + "address": "0x1400089b3", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x70]" + }, + { + "address": "0x1400089b8", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax]" + }, + { + "address": "0x1400089bb", + "size": 4, + "mnemonic": "movsxd", + "operands": "rdx, dword ptr [rax + 0x10]" + }, + { + "address": "0x1400089bf", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ebx" + }, + { + "address": "0x1400089c1", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + rax*4]" + }, + { + "address": "0x1400089c5", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [r9 + 8]" + }, + { + "address": "0x1400089c9", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rdx + rcx*4]" + }, + { + "address": "0x1400089cd", + "size": 5, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [r8 + rax]" + }, + { + "address": "0x1400089d2", + "size": 5, + "mnemonic": "movsxd", + "operands": "rdx, dword ptr [r8 + rax + 0x10]" + }, + { + "address": "0x1400089d7", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x90], edx" + }, + { + "address": "0x1400089de", + "size": 4, + "mnemonic": "movd", + "operands": "eax, xmm0" + }, + { + "address": "0x1400089e2", + "size": 8, + "mnemonic": "movups", + "operands": "xmmword ptr [rsp + 0x80], xmm0" + }, + { + "address": "0x1400089ea", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, r14d" + }, + { + "address": "0x1400089ed", + "size": 6, + "mnemonic": "jg", + "operands": "0x140008ab1" + } + ], + "successors": [ + "0x140008ab1", + "0x1400089f3" + ] + }, + { + "address": "0x1400088e5", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400088e5", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x1400088e7", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x17713]" + }, + { + "address": "0x1400088ed", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x1400088f0", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x1400088f5", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [rax + 0x10], rbx" + }, + { + "address": "0x1400088f9", + "size": 2, + "mnemonic": "je", + "operands": "0x140008940" + } + ], + "successors": [ + "0x140008940", + "0x1400088fb" + ] + }, + { + "address": "0x140008ab1", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008ab1", + "size": 8, + "mnemonic": "mov", + "operands": "r9, qword ptr [rsp + 0x100]" + }, + { + "address": "0x140008ab9", + "size": 2, + "mnemonic": "inc", + "operands": "ebx" + }, + { + "address": "0x140008abb", + "size": 7, + "mnemonic": "cmp", + "operands": "ebx, dword ptr [rsp + 0xb0]" + }, + { + "address": "0x140008ac2", + "size": 6, + "mnemonic": "jb", + "operands": "0x1400089b3" + } + ], + "successors": [ + "0x1400089b3", + "0x140008ac8" + ] + }, + { + "address": "0x1400089f3", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400089f3", + "size": 5, + "mnemonic": "movq", + "operands": "rax, xmm0" + }, + { + "address": "0x1400089f8", + "size": 4, + "mnemonic": "shr", + "operands": "rax, 0x20" + }, + { + "address": "0x1400089fc", + "size": 3, + "mnemonic": "cmp", + "operands": "r14d, eax" + }, + { + "address": "0x1400089ff", + "size": 6, + "mnemonic": "jg", + "operands": "0x140008ab1" + } + ], + "successors": [ + "0x140008ab1", + "0x140008a05" + ] + }, + { + "address": "0x1400088fb", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400088fb", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rsi], 0xe0434f4d" + }, + { + "address": "0x140008901", + "size": 2, + "mnemonic": "je", + "operands": "0x140008940" + } + ], + "successors": [ + "0x140008940", + "0x140008903" + ] + }, + { + "address": "0x1400089b3", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400089b3", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x70]" + }, + { + "address": "0x1400089b8", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax]" + }, + { + "address": "0x1400089bb", + "size": 4, + "mnemonic": "movsxd", + "operands": "rdx, dword ptr [rax + 0x10]" + }, + { + "address": "0x1400089bf", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ebx" + }, + { + "address": "0x1400089c1", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + rax*4]" + }, + { + "address": "0x1400089c5", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [r9 + 8]" + }, + { + "address": "0x1400089c9", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rdx + rcx*4]" + }, + { + "address": "0x1400089cd", + "size": 5, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [r8 + rax]" + }, + { + "address": "0x1400089d2", + "size": 5, + "mnemonic": "movsxd", + "operands": "rdx, dword ptr [r8 + rax + 0x10]" + }, + { + "address": "0x1400089d7", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x90], edx" + }, + { + "address": "0x1400089de", + "size": 4, + "mnemonic": "movd", + "operands": "eax, xmm0" + }, + { + "address": "0x1400089e2", + "size": 8, + "mnemonic": "movups", + "operands": "xmmword ptr [rsp + 0x80], xmm0" + }, + { + "address": "0x1400089ea", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, r14d" + }, + { + "address": "0x1400089ed", + "size": 6, + "mnemonic": "jg", + "operands": "0x140008ab1" + } + ], + "successors": [ + "0x140008ab1", + "0x1400089f3" + ] + }, + { + "address": "0x140008a05", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008a05", + "size": 4, + "mnemonic": "mov", + "operands": "r15, qword ptr [rbp + 8]" + }, + { + "address": "0x140008a09", + "size": 4, + "mnemonic": "add", + "operands": "r15, -0x14" + }, + { + "address": "0x140008a0d", + "size": 5, + "mnemonic": "psrldq", + "operands": "xmm0, 8" + }, + { + "address": "0x140008a12", + "size": 5, + "mnemonic": "movq", + "operands": "rax, xmm0" + }, + { + "address": "0x140008a17", + "size": 4, + "mnemonic": "shr", + "operands": "rax, 0x20" + }, + { + "address": "0x140008a1b", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + rax*4]" + }, + { + "address": "0x140008a1f", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rdx + rcx*4]" + }, + { + "address": "0x140008a23", + "size": 3, + "mnemonic": "add", + "operands": "r15, rdx" + }, + { + "address": "0x140008a26", + "size": 4, + "mnemonic": "movsxd", + "operands": "r12, dword ptr [r15 + 4]" + }, + { + "address": "0x140008a2a", + "size": 3, + "mnemonic": "test", + "operands": "r12d, r12d" + }, + { + "address": "0x140008a2d", + "size": 2, + "mnemonic": "je", + "operands": "0x140008a54" + } + ], + "successors": [ + "0x140008a54", + "0x140008a2f" + ] + }, + { + "address": "0x140008903", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008903", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rsi], 0xe0434352" + }, + { + "address": "0x140008909", + "size": 2, + "mnemonic": "je", + "operands": "0x140008940" + } + ], + "successors": [ + "0x140008940", + "0x14000890b" + ] + }, + { + "address": "0x140008a54", + "size": 21, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008a54", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [r15], 0x40" + }, + { + "address": "0x140008a58", + "size": 2, + "mnemonic": "jne", + "operands": "0x140008ab1" + }, + { + "address": "0x140008a5a", + "size": 8, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x138]" + }, + { + "address": "0x140008a62", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rbp" + }, + { + "address": "0x140008a65", + "size": 8, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsp + 0x110]" + }, + { + "address": "0x140008a6d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x140008a70", + "size": 8, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rsp + 0x108]" + }, + { + "address": "0x140008a78", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x58], 0" + }, + { + "address": "0x140008a7d", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x50], 1" + }, + { + "address": "0x140008a82", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x48], rax" + }, + { + "address": "0x140008a87", + "size": 8, + "mnemonic": "lea", + "operands": "rax, [rsp + 0x80]" + }, + { + "address": "0x140008a8f", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x40], r13d" + }, + { + "address": "0x140008a94", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], rax" + }, + { + "address": "0x140008a99", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], 0" + }, + { + "address": "0x140008aa2", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], r15" + }, + { + "address": "0x140008aa7", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rdi" + }, + { + "address": "0x140008aac", + "size": 5, + "mnemonic": "call", + "operands": "0x140007cb0" + }, + { + "address": "0x140008ab1", + "size": 8, + "mnemonic": "mov", + "operands": "r9, qword ptr [rsp + 0x100]" + }, + { + "address": "0x140008ab9", + "size": 2, + "mnemonic": "inc", + "operands": "ebx" + }, + { + "address": "0x140008abb", + "size": 7, + "mnemonic": "cmp", + "operands": "ebx, dword ptr [rsp + 0xb0]" + }, + { + "address": "0x140008ac2", + "size": 6, + "mnemonic": "jb", + "operands": "0x1400089b3" + } + ], + "successors": [ + "0x1400089b3", + "0x140008ac8" + ] + }, + { + "address": "0x140008a2f", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008a2f", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140008a34", + "size": 3, + "mnemonic": "add", + "operands": "rax, r12" + }, + { + "address": "0x140008a37", + "size": 2, + "mnemonic": "je", + "operands": "0x140008a54" + } + ], + "successors": [ + "0x140008a54", + "0x140008a39" + ] + }, + { + "address": "0x14000890b", + "size": 48, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000890b", + "size": 8, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x138]" + }, + { + "address": "0x140008913", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rbp" + }, + { + "address": "0x140008916", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x38], r14d" + }, + { + "address": "0x14000891b", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r15" + }, + { + "address": "0x14000891e", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rax" + }, + { + "address": "0x140008923", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r12" + }, + { + "address": "0x140008926", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], r13d" + }, + { + "address": "0x14000892b", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x14000892e", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rdi" + }, + { + "address": "0x140008933", + "size": 5, + "mnemonic": "call", + "operands": "0x140006240" + }, + { + "address": "0x140008938", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000893a", + "size": 6, + "mnemonic": "jne", + "operands": "0x140008ac8" + }, + { + "address": "0x140008940", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 8]" + }, + { + "address": "0x140008944", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x68], rax" + }, + { + "address": "0x140008949", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x60], rdi" + }, + { + "address": "0x14000894e", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rdi + 0xc], 0" + }, + { + "address": "0x140008952", + "size": 6, + "mnemonic": "jbe", + "operands": "0x140008ae3" + }, + { + "address": "0x140008958", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], r13d" + }, + { + "address": "0x14000895d", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x60]" + }, + { + "address": "0x140008962", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rbp" + }, + { + "address": "0x140008965", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rdi" + }, + { + "address": "0x14000896a", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, r14d" + }, + { + "address": "0x14000896d", + "size": 8, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x98]" + }, + { + "address": "0x140008975", + "size": 5, + "mnemonic": "call", + "operands": "0x140006650" + }, + { + "address": "0x14000897a", + "size": 8, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rsp + 0x98]" + }, + { + "address": "0x140008982", + "size": 4, + "mnemonic": "movdqa", + "operands": "xmm0, xmm1" + }, + { + "address": "0x140008986", + "size": 5, + "mnemonic": "psrldq", + "operands": "xmm0, 8" + }, + { + "address": "0x14000898b", + "size": 4, + "mnemonic": "movd", + "operands": "eax, xmm0" + }, + { + "address": "0x14000898f", + "size": 6, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rsp + 0x70], xmm1" + }, + { + "address": "0x140008995", + "size": 7, + "mnemonic": "cmp", + "operands": "eax, dword ptr [rsp + 0xb0]" + }, + { + "address": "0x14000899c", + "size": 6, + "mnemonic": "jae", + "operands": "0x140008ac8" + }, + { + "address": "0x1400089a2", + "size": 4, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rsp + 0x78]" + }, + { + "address": "0x1400089a6", + "size": 5, + "mnemonic": "movq", + "operands": "r9, xmm1" + }, + { + "address": "0x1400089ab", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x100], r9" + }, + { + "address": "0x1400089b3", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x70]" + }, + { + "address": "0x1400089b8", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax]" + }, + { + "address": "0x1400089bb", + "size": 4, + "mnemonic": "movsxd", + "operands": "rdx, dword ptr [rax + 0x10]" + }, + { + "address": "0x1400089bf", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ebx" + }, + { + "address": "0x1400089c1", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + rax*4]" + }, + { + "address": "0x1400089c5", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [r9 + 8]" + }, + { + "address": "0x1400089c9", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rdx + rcx*4]" + }, + { + "address": "0x1400089cd", + "size": 5, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [r8 + rax]" + }, + { + "address": "0x1400089d2", + "size": 5, + "mnemonic": "movsxd", + "operands": "rdx, dword ptr [r8 + rax + 0x10]" + }, + { + "address": "0x1400089d7", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x90], edx" + }, + { + "address": "0x1400089de", + "size": 4, + "mnemonic": "movd", + "operands": "eax, xmm0" + }, + { + "address": "0x1400089e2", + "size": 8, + "mnemonic": "movups", + "operands": "xmmword ptr [rsp + 0x80], xmm0" + }, + { + "address": "0x1400089ea", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, r14d" + }, + { + "address": "0x1400089ed", + "size": 6, + "mnemonic": "jg", + "operands": "0x140008ab1" + } + ], + "successors": [ + "0x140008ab1", + "0x1400089f3" + ] + }, + { + "address": "0x140008a39", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008a39", + "size": 4, + "mnemonic": "movsxd", + "operands": "r12, dword ptr [r15 + 4]" + }, + { + "address": "0x140008a3d", + "size": 3, + "mnemonic": "test", + "operands": "r12d, r12d" + }, + { + "address": "0x140008a40", + "size": 2, + "mnemonic": "je", + "operands": "0x140008a4c" + } + ], + "successors": [ + "0x140008a4c", + "0x140008a42" + ] + }, + { + "address": "0x140008a4c", + "size": 24, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008a4c", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140008a4e", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rax + 0x10], 0" + }, + { + "address": "0x140008a52", + "size": 2, + "mnemonic": "jne", + "operands": "0x140008ab1" + }, + { + "address": "0x140008a54", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [r15], 0x40" + }, + { + "address": "0x140008a58", + "size": 2, + "mnemonic": "jne", + "operands": "0x140008ab1" + }, + { + "address": "0x140008a5a", + "size": 8, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x138]" + }, + { + "address": "0x140008a62", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rbp" + }, + { + "address": "0x140008a65", + "size": 8, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsp + 0x110]" + }, + { + "address": "0x140008a6d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x140008a70", + "size": 8, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rsp + 0x108]" + }, + { + "address": "0x140008a78", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x58], 0" + }, + { + "address": "0x140008a7d", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x50], 1" + }, + { + "address": "0x140008a82", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x48], rax" + }, + { + "address": "0x140008a87", + "size": 8, + "mnemonic": "lea", + "operands": "rax, [rsp + 0x80]" + }, + { + "address": "0x140008a8f", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x40], r13d" + }, + { + "address": "0x140008a94", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], rax" + }, + { + "address": "0x140008a99", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], 0" + }, + { + "address": "0x140008aa2", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], r15" + }, + { + "address": "0x140008aa7", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rdi" + }, + { + "address": "0x140008aac", + "size": 5, + "mnemonic": "call", + "operands": "0x140007cb0" + }, + { + "address": "0x140008ab1", + "size": 8, + "mnemonic": "mov", + "operands": "r9, qword ptr [rsp + 0x100]" + }, + { + "address": "0x140008ab9", + "size": 2, + "mnemonic": "inc", + "operands": "ebx" + }, + { + "address": "0x140008abb", + "size": 7, + "mnemonic": "cmp", + "operands": "ebx, dword ptr [rsp + 0xb0]" + }, + { + "address": "0x140008ac2", + "size": 6, + "mnemonic": "jb", + "operands": "0x1400089b3" + } + ], + "successors": [ + "0x1400089b3", + "0x140008ac8" + ] + }, + { + "address": "0x140008a42", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008a42", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140008a47", + "size": 3, + "mnemonic": "add", + "operands": "rax, r12" + }, + { + "address": "0x140008a4a", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140008a4e" + } + ], + "successors": [ + "0x140008a4e" + ] + }, + { + "address": "0x140008a4e", + "size": 23, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008a4e", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rax + 0x10], 0" + }, + { + "address": "0x140008a52", + "size": 2, + "mnemonic": "jne", + "operands": "0x140008ab1" + }, + { + "address": "0x140008a54", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [r15], 0x40" + }, + { + "address": "0x140008a58", + "size": 2, + "mnemonic": "jne", + "operands": "0x140008ab1" + }, + { + "address": "0x140008a5a", + "size": 8, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x138]" + }, + { + "address": "0x140008a62", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rbp" + }, + { + "address": "0x140008a65", + "size": 8, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsp + 0x110]" + }, + { + "address": "0x140008a6d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x140008a70", + "size": 8, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rsp + 0x108]" + }, + { + "address": "0x140008a78", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x58], 0" + }, + { + "address": "0x140008a7d", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x50], 1" + }, + { + "address": "0x140008a82", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x48], rax" + }, + { + "address": "0x140008a87", + "size": 8, + "mnemonic": "lea", + "operands": "rax, [rsp + 0x80]" + }, + { + "address": "0x140008a8f", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x40], r13d" + }, + { + "address": "0x140008a94", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], rax" + }, + { + "address": "0x140008a99", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], 0" + }, + { + "address": "0x140008aa2", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], r15" + }, + { + "address": "0x140008aa7", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rdi" + }, + { + "address": "0x140008aac", + "size": 5, + "mnemonic": "call", + "operands": "0x140007cb0" + }, + { + "address": "0x140008ab1", + "size": 8, + "mnemonic": "mov", + "operands": "r9, qword ptr [rsp + 0x100]" + }, + { + "address": "0x140008ab9", + "size": 2, + "mnemonic": "inc", + "operands": "ebx" + }, + { + "address": "0x140008abb", + "size": 7, + "mnemonic": "cmp", + "operands": "ebx, dword ptr [rsp + 0xb0]" + }, + { + "address": "0x140008ac2", + "size": 6, + "mnemonic": "jb", + "operands": "0x1400089b3" + } + ], + "successors": [ + "0x1400089b3", + "0x140008ac8" + ] + } + ] + }, + { + "address": "0x140008aec", + "name": "", + "blocks": [ + { + "address": "0x140008aec", + "size": 23, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008aec", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140008aee", + "size": 1, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140008aef", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140008af0", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140008af1", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140008af3", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140008af5", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140008af7", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140008af9", + "size": 5, + "mnemonic": "lea", + "operands": "rbp, [rsp - 0x38]" + }, + { + "address": "0x140008afe", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x138" + }, + { + "address": "0x140008b05", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x28534]" + }, + { + "address": "0x140008b0c", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x140008b0f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x28], rax" + }, + { + "address": "0x140008b13", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rcx], 0x80000003" + }, + { + "address": "0x140008b19", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r9" + }, + { + "address": "0x140008b1c", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0xb8]" + }, + { + "address": "0x140008b23", + "size": 3, + "mnemonic": "mov", + "operands": "r13, rdx" + }, + { + "address": "0x140008b26", + "size": 7, + "mnemonic": "mov", + "operands": "r15, qword ptr [rbp + 0xa0]" + }, + { + "address": "0x140008b2d", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rcx" + }, + { + "address": "0x140008b30", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x68], rax" + }, + { + "address": "0x140008b35", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x70], r8" + }, + { + "address": "0x140008b3a", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x78], rdx" + }, + { + "address": "0x140008b3e", + "size": 6, + "mnemonic": "je", + "operands": "0x140008dcc" + } + ], + "successors": [ + "0x140008dcc", + "0x140008b44" + ] + }, + { + "address": "0x140008dcc", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140008dcc", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x28]" + }, + { + "address": "0x140008dd0", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x140008dd3", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140008dd8", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0x138" + }, + { + "address": "0x140008ddf", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140008de1", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140008de3", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140008de5", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140008de7", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140008de8", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140008de9", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140008dea", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140008deb", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140008b44", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008b44", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140008b49", + "size": 7, + "mnemonic": "mov", + "operands": "r12d, dword ptr [rbp + 0xb0]" + }, + { + "address": "0x140008b50", + "size": 7, + "mnemonic": "mov", + "operands": "r14d, dword ptr [rbp + 0xa8]" + }, + { + "address": "0x140008b57", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rax + 0x10], 0" + }, + { + "address": "0x140008b5c", + "size": 2, + "mnemonic": "je", + "operands": "0x140008bb8" + } + ], + "successors": [ + "0x140008bb8", + "0x140008b5e" + ] + }, + { + "address": "0x140008bb8", + "size": 29, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008bb8", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [rdi + 8]" + }, + { + "address": "0x140008bbc", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp]" + }, + { + "address": "0x140008bc0", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r15" + }, + { + "address": "0x140008bc3", + "size": 5, + "mnemonic": "call", + "operands": "0x140009604" + }, + { + "address": "0x140008bc8", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rbp], 0" + }, + { + "address": "0x140008bcc", + "size": 6, + "mnemonic": "jbe", + "operands": "0x140008dec" + }, + { + "address": "0x140008bd2", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], r12d" + }, + { + "address": "0x140008bd7", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp]" + }, + { + "address": "0x140008bdb", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rdi" + }, + { + "address": "0x140008bde", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r15" + }, + { + "address": "0x140008be3", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, r14d" + }, + { + "address": "0x140008be6", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x70]" + }, + { + "address": "0x140008bea", + "size": 5, + "mnemonic": "call", + "operands": "0x140006788" + }, + { + "address": "0x140008bef", + "size": 4, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rbp - 0x70]" + }, + { + "address": "0x140008bf3", + "size": 4, + "mnemonic": "movdqa", + "operands": "xmm0, xmm1" + }, + { + "address": "0x140008bf7", + "size": 5, + "mnemonic": "psrldq", + "operands": "xmm0, 8" + }, + { + "address": "0x140008bfc", + "size": 4, + "mnemonic": "movd", + "operands": "eax, xmm0" + }, + { + "address": "0x140008c00", + "size": 6, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rsp + 0x78], xmm1" + }, + { + "address": "0x140008c06", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, dword ptr [rbp - 0x58]" + }, + { + "address": "0x140008c09", + "size": 6, + "mnemonic": "jae", + "operands": "0x140008dcc" + }, + { + "address": "0x140008c0f", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbp - 0x80]" + }, + { + "address": "0x140008c12", + "size": 7, + "mnemonic": "lea", + "operands": "r11, [rip - 0x8c19]" + }, + { + "address": "0x140008c19", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x60], eax" + }, + { + "address": "0x140008c1d", + "size": 5, + "mnemonic": "movq", + "operands": "r13, xmm1" + }, + { + "address": "0x140008c22", + "size": 5, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [r13 + 0x18]" + }, + { + "address": "0x140008c27", + "size": 5, + "mnemonic": "movq", + "operands": "rax, xmm0" + }, + { + "address": "0x140008c2c", + "size": 5, + "mnemonic": "movups", + "operands": "xmmword ptr [rsp + 0x78], xmm0" + }, + { + "address": "0x140008c31", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, r14d" + }, + { + "address": "0x140008c34", + "size": 6, + "mnemonic": "jg", + "operands": "0x140008d20" + } + ], + "successors": [ + "0x140008d20", + "0x140008c3a" + ] + }, + { + "address": "0x140008b5e", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008b5e", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x140008b60", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1749a]" + }, + { + "address": "0x140008b66", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x140008b69", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140008b6e", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [rax + 0x10], rbx" + }, + { + "address": "0x140008b72", + "size": 2, + "mnemonic": "je", + "operands": "0x140008bb8" + } + ], + "successors": [ + "0x140008bb8", + "0x140008b74" + ] + }, + { + "address": "0x140008d20", + "size": 42, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008d20", + "size": 4, + "mnemonic": "mov", + "operands": "r10, qword ptr [r13 + 8]" + }, + { + "address": "0x140008d24", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r10" + }, + { + "address": "0x140008d27", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [r10]" + }, + { + "address": "0x140008d2b", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140008d2e", + "size": 9, + "mnemonic": "movsx", + "operands": "r9, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x140008d37", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140008d3f", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x140008d42", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x140008d45", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140008d47", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r13 + 8], rdx" + }, + { + "address": "0x140008d4b", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r13 + 0x18], eax" + }, + { + "address": "0x140008d4f", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140008d52", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r10" + }, + { + "address": "0x140008d55", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140008d58", + "size": 9, + "mnemonic": "movsx", + "operands": "r8, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x140008d61", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140008d69", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r8" + }, + { + "address": "0x140008d6c", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x140008d6f", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x140008d72", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140008d74", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r13 + 0x1c], eax" + }, + { + "address": "0x140008d78", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r13 + 8], rdx" + }, + { + "address": "0x140008d7c", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140008d7f", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140008d82", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x140008d8b", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140008d93", + "size": 3, + "mnemonic": "sub", + "operands": "r10, rax" + }, + { + "address": "0x140008d96", + "size": 3, + "mnemonic": "sub", + "operands": "r10, r8" + }, + { + "address": "0x140008d99", + "size": 3, + "mnemonic": "sub", + "operands": "r10, r9" + }, + { + "address": "0x140008d9c", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r10 - 4]" + }, + { + "address": "0x140008da0", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140008da2", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r13 + 0x20], eax" + }, + { + "address": "0x140008da6", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r10 + 4]" + }, + { + "address": "0x140008daa", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r13 + 8], r10" + }, + { + "address": "0x140008dae", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [r10]" + }, + { + "address": "0x140008db1", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r13 + 0x24], ecx" + }, + { + "address": "0x140008db5", + "size": 4, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rsp + 0x60]" + }, + { + "address": "0x140008db9", + "size": 2, + "mnemonic": "inc", + "operands": "ecx" + }, + { + "address": "0x140008dbb", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r13 + 8], rax" + }, + { + "address": "0x140008dbf", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x60], ecx" + }, + { + "address": "0x140008dc3", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, dword ptr [rbp - 0x58]" + }, + { + "address": "0x140008dc6", + "size": 6, + "mnemonic": "jb", + "operands": "0x140008c22" + } + ], + "successors": [ + "0x140008c22", + "0x140008dcc" + ] + }, + { + "address": "0x140008c3a", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008c3a", + "size": 4, + "mnemonic": "shr", + "operands": "rax, 0x20" + }, + { + "address": "0x140008c3e", + "size": 3, + "mnemonic": "cmp", + "operands": "r14d, eax" + }, + { + "address": "0x140008c41", + "size": 6, + "mnemonic": "jg", + "operands": "0x140008d20" + } + ], + "successors": [ + "0x140008d20", + "0x140008c47" + ] + }, + { + "address": "0x140008b74", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008b74", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rsi], 0xe0434f4d" + }, + { + "address": "0x140008b7a", + "size": 2, + "mnemonic": "je", + "operands": "0x140008bb8" + } + ], + "successors": [ + "0x140008bb8", + "0x140008b7c" + ] + }, + { + "address": "0x140008c22", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008c22", + "size": 5, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [r13 + 0x18]" + }, + { + "address": "0x140008c27", + "size": 5, + "mnemonic": "movq", + "operands": "rax, xmm0" + }, + { + "address": "0x140008c2c", + "size": 5, + "mnemonic": "movups", + "operands": "xmmword ptr [rsp + 0x78], xmm0" + }, + { + "address": "0x140008c31", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, r14d" + }, + { + "address": "0x140008c34", + "size": 6, + "mnemonic": "jg", + "operands": "0x140008d20" + } + ], + "successors": [ + "0x140008d20", + "0x140008c3a" + ] + }, + { + "address": "0x140008c47", + "size": 17, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008c47", + "size": 4, + "mnemonic": "mov", + "operands": "r9, qword ptr [rdi + 0x10]" + }, + { + "address": "0x140008c4b", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x78]" + }, + { + "address": "0x140008c50", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [rdi + 8]" + }, + { + "address": "0x140008c54", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x50]" + }, + { + "address": "0x140008c58", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, dword ptr [r9]" + }, + { + "address": "0x140008c5b", + "size": 5, + "mnemonic": "call", + "operands": "0x140009580" + }, + { + "address": "0x140008c60", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp - 0x40]" + }, + { + "address": "0x140008c64", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x50]" + }, + { + "address": "0x140008c68", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x48], rax" + }, + { + "address": "0x140008c6c", + "size": 5, + "mnemonic": "call", + "operands": "0x140009b74" + }, + { + "address": "0x140008c71", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp - 0x40]" + }, + { + "address": "0x140008c75", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x50]" + }, + { + "address": "0x140008c79", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0x50]" + }, + { + "address": "0x140008c7c", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x48], rax" + }, + { + "address": "0x140008c80", + "size": 5, + "mnemonic": "call", + "operands": "0x140009b74" + }, + { + "address": "0x140008c85", + "size": 3, + "mnemonic": "sub", + "operands": "ebx, 1" + }, + { + "address": "0x140008c88", + "size": 2, + "mnemonic": "je", + "operands": "0x140008c99" + } + ], + "successors": [ + "0x140008c99", + "0x140008c8a" + ] + }, + { + "address": "0x140008b7c", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008b7c", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rsi], 0xe0434352" + }, + { + "address": "0x140008b82", + "size": 2, + "mnemonic": "je", + "operands": "0x140008bb8" + } + ], + "successors": [ + "0x140008bb8", + "0x140008b84" + ] + }, + { + "address": "0x140008c99", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008c99", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rbp - 0x30]" + }, + { + "address": "0x140008c9d", + "size": 2, + "mnemonic": "test", + "operands": "ebx, ebx" + }, + { + "address": "0x140008c9f", + "size": 2, + "mnemonic": "je", + "operands": "0x140008cc5" + } + ], + "successors": [ + "0x140008cc5", + "0x140008ca1" + ] + }, + { + "address": "0x140008c8a", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008c8a", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x50]" + }, + { + "address": "0x140008c8e", + "size": 5, + "mnemonic": "call", + "operands": "0x140009b74" + }, + { + "address": "0x140008c93", + "size": 4, + "mnemonic": "sub", + "operands": "rbx, 1" + }, + { + "address": "0x140008c97", + "size": 2, + "mnemonic": "jne", + "operands": "0x140008c8a" + }, + { + "address": "0x140008c99", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rbp - 0x30]" + }, + { + "address": "0x140008c9d", + "size": 2, + "mnemonic": "test", + "operands": "ebx, ebx" + }, + { + "address": "0x140008c9f", + "size": 2, + "mnemonic": "je", + "operands": "0x140008cc5" + } + ], + "successors": [ + "0x140008cc5", + "0x140008ca1" + ] + }, + { + "address": "0x140008b84", + "size": 41, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008b84", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x68]" + }, + { + "address": "0x140008b89", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rdi" + }, + { + "address": "0x140008b8c", + "size": 5, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140008b91", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r13" + }, + { + "address": "0x140008b94", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x38], r14d" + }, + { + "address": "0x140008b99", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x140008b9c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rax" + }, + { + "address": "0x140008ba1", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], r12d" + }, + { + "address": "0x140008ba6", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r15" + }, + { + "address": "0x140008bab", + "size": 5, + "mnemonic": "call", + "operands": "0x140006294" + }, + { + "address": "0x140008bb0", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140008bb2", + "size": 6, + "mnemonic": "jne", + "operands": "0x140008dcc" + }, + { + "address": "0x140008bb8", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [rdi + 8]" + }, + { + "address": "0x140008bbc", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp]" + }, + { + "address": "0x140008bc0", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r15" + }, + { + "address": "0x140008bc3", + "size": 5, + "mnemonic": "call", + "operands": "0x140009604" + }, + { + "address": "0x140008bc8", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rbp], 0" + }, + { + "address": "0x140008bcc", + "size": 6, + "mnemonic": "jbe", + "operands": "0x140008dec" + }, + { + "address": "0x140008bd2", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], r12d" + }, + { + "address": "0x140008bd7", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp]" + }, + { + "address": "0x140008bdb", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rdi" + }, + { + "address": "0x140008bde", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r15" + }, + { + "address": "0x140008be3", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, r14d" + }, + { + "address": "0x140008be6", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x70]" + }, + { + "address": "0x140008bea", + "size": 5, + "mnemonic": "call", + "operands": "0x140006788" + }, + { + "address": "0x140008bef", + "size": 4, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rbp - 0x70]" + }, + { + "address": "0x140008bf3", + "size": 4, + "mnemonic": "movdqa", + "operands": "xmm0, xmm1" + }, + { + "address": "0x140008bf7", + "size": 5, + "mnemonic": "psrldq", + "operands": "xmm0, 8" + }, + { + "address": "0x140008bfc", + "size": 4, + "mnemonic": "movd", + "operands": "eax, xmm0" + }, + { + "address": "0x140008c00", + "size": 6, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rsp + 0x78], xmm1" + }, + { + "address": "0x140008c06", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, dword ptr [rbp - 0x58]" + }, + { + "address": "0x140008c09", + "size": 6, + "mnemonic": "jae", + "operands": "0x140008dcc" + }, + { + "address": "0x140008c0f", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbp - 0x80]" + }, + { + "address": "0x140008c12", + "size": 7, + "mnemonic": "lea", + "operands": "r11, [rip - 0x8c19]" + }, + { + "address": "0x140008c19", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x60], eax" + }, + { + "address": "0x140008c1d", + "size": 5, + "mnemonic": "movq", + "operands": "r13, xmm1" + }, + { + "address": "0x140008c22", + "size": 5, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [r13 + 0x18]" + }, + { + "address": "0x140008c27", + "size": 5, + "mnemonic": "movq", + "operands": "rax, xmm0" + }, + { + "address": "0x140008c2c", + "size": 5, + "mnemonic": "movups", + "operands": "xmmword ptr [rsp + 0x78], xmm0" + }, + { + "address": "0x140008c31", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, r14d" + }, + { + "address": "0x140008c34", + "size": 6, + "mnemonic": "jg", + "operands": "0x140008d20" + } + ], + "successors": [ + "0x140008d20", + "0x140008c3a" + ] + }, + { + "address": "0x140008cc5", + "size": 61, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008cc5", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [rbp - 0x34], 0x40" + }, + { + "address": "0x140008cc9", + "size": 2, + "mnemonic": "jne", + "operands": "0x140008d19" + }, + { + "address": "0x140008ccb", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x68]" + }, + { + "address": "0x140008cd0", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rdi" + }, + { + "address": "0x140008cd3", + "size": 5, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140008cd8", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x140008cdb", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rbp - 0x78]" + }, + { + "address": "0x140008cdf", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x58], 0" + }, + { + "address": "0x140008ce4", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x50], 1" + }, + { + "address": "0x140008ce9", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x48], rax" + }, + { + "address": "0x140008cee", + "size": 5, + "mnemonic": "lea", + "operands": "rax, [rsp + 0x78]" + }, + { + "address": "0x140008cf3", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x40], r12d" + }, + { + "address": "0x140008cf8", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], rax" + }, + { + "address": "0x140008cfd", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp - 0x38]" + }, + { + "address": "0x140008d01", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], 0" + }, + { + "address": "0x140008d0a", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x140008d0f", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r15" + }, + { + "address": "0x140008d14", + "size": 5, + "mnemonic": "call", + "operands": "0x140007d88" + }, + { + "address": "0x140008d19", + "size": 7, + "mnemonic": "lea", + "operands": "r11, [rip - 0x8d20]" + }, + { + "address": "0x140008d20", + "size": 4, + "mnemonic": "mov", + "operands": "r10, qword ptr [r13 + 8]" + }, + { + "address": "0x140008d24", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r10" + }, + { + "address": "0x140008d27", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [r10]" + }, + { + "address": "0x140008d2b", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140008d2e", + "size": 9, + "mnemonic": "movsx", + "operands": "r9, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x140008d37", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140008d3f", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x140008d42", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x140008d45", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140008d47", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r13 + 8], rdx" + }, + { + "address": "0x140008d4b", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r13 + 0x18], eax" + }, + { + "address": "0x140008d4f", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140008d52", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r10" + }, + { + "address": "0x140008d55", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140008d58", + "size": 9, + "mnemonic": "movsx", + "operands": "r8, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x140008d61", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140008d69", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r8" + }, + { + "address": "0x140008d6c", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x140008d6f", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x140008d72", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140008d74", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r13 + 0x1c], eax" + }, + { + "address": "0x140008d78", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r13 + 8], rdx" + }, + { + "address": "0x140008d7c", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140008d7f", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140008d82", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x140008d8b", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140008d93", + "size": 3, + "mnemonic": "sub", + "operands": "r10, rax" + }, + { + "address": "0x140008d96", + "size": 3, + "mnemonic": "sub", + "operands": "r10, r8" + }, + { + "address": "0x140008d99", + "size": 3, + "mnemonic": "sub", + "operands": "r10, r9" + }, + { + "address": "0x140008d9c", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r10 - 4]" + }, + { + "address": "0x140008da0", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140008da2", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r13 + 0x20], eax" + }, + { + "address": "0x140008da6", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r10 + 4]" + }, + { + "address": "0x140008daa", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r13 + 8], r10" + }, + { + "address": "0x140008dae", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [r10]" + }, + { + "address": "0x140008db1", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r13 + 0x24], ecx" + }, + { + "address": "0x140008db5", + "size": 4, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rsp + 0x60]" + }, + { + "address": "0x140008db9", + "size": 2, + "mnemonic": "inc", + "operands": "ecx" + }, + { + "address": "0x140008dbb", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r13 + 8], rax" + }, + { + "address": "0x140008dbf", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x60], ecx" + }, + { + "address": "0x140008dc3", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, dword ptr [rbp - 0x58]" + }, + { + "address": "0x140008dc6", + "size": 6, + "mnemonic": "jb", + "operands": "0x140008c22" + } + ], + "successors": [ + "0x140008c22", + "0x140008dcc" + ] + }, + { + "address": "0x140008ca1", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008ca1", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140008ca6", + "size": 3, + "mnemonic": "add", + "operands": "rax, rbx" + }, + { + "address": "0x140008ca9", + "size": 2, + "mnemonic": "je", + "operands": "0x140008cc5" + } + ], + "successors": [ + "0x140008cc5", + "0x140008cab" + ] + }, + { + "address": "0x140008cab", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008cab", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rbp - 0x30]" + }, + { + "address": "0x140008caf", + "size": 2, + "mnemonic": "test", + "operands": "ebx, ebx" + }, + { + "address": "0x140008cb1", + "size": 2, + "mnemonic": "je", + "operands": "0x140008cbd" + } + ], + "successors": [ + "0x140008cbd", + "0x140008cb3" + ] + }, + { + "address": "0x140008cbd", + "size": 64, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008cbd", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140008cbf", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rax + 0x10], 0" + }, + { + "address": "0x140008cc3", + "size": 2, + "mnemonic": "jne", + "operands": "0x140008d19" + }, + { + "address": "0x140008cc5", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [rbp - 0x34], 0x40" + }, + { + "address": "0x140008cc9", + "size": 2, + "mnemonic": "jne", + "operands": "0x140008d19" + }, + { + "address": "0x140008ccb", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x68]" + }, + { + "address": "0x140008cd0", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rdi" + }, + { + "address": "0x140008cd3", + "size": 5, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140008cd8", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x140008cdb", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rbp - 0x78]" + }, + { + "address": "0x140008cdf", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x58], 0" + }, + { + "address": "0x140008ce4", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x50], 1" + }, + { + "address": "0x140008ce9", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x48], rax" + }, + { + "address": "0x140008cee", + "size": 5, + "mnemonic": "lea", + "operands": "rax, [rsp + 0x78]" + }, + { + "address": "0x140008cf3", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x40], r12d" + }, + { + "address": "0x140008cf8", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], rax" + }, + { + "address": "0x140008cfd", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp - 0x38]" + }, + { + "address": "0x140008d01", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], 0" + }, + { + "address": "0x140008d0a", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x140008d0f", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r15" + }, + { + "address": "0x140008d14", + "size": 5, + "mnemonic": "call", + "operands": "0x140007d88" + }, + { + "address": "0x140008d19", + "size": 7, + "mnemonic": "lea", + "operands": "r11, [rip - 0x8d20]" + }, + { + "address": "0x140008d20", + "size": 4, + "mnemonic": "mov", + "operands": "r10, qword ptr [r13 + 8]" + }, + { + "address": "0x140008d24", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r10" + }, + { + "address": "0x140008d27", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [r10]" + }, + { + "address": "0x140008d2b", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140008d2e", + "size": 9, + "mnemonic": "movsx", + "operands": "r9, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x140008d37", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140008d3f", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x140008d42", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x140008d45", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140008d47", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r13 + 8], rdx" + }, + { + "address": "0x140008d4b", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r13 + 0x18], eax" + }, + { + "address": "0x140008d4f", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140008d52", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r10" + }, + { + "address": "0x140008d55", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140008d58", + "size": 9, + "mnemonic": "movsx", + "operands": "r8, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x140008d61", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140008d69", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r8" + }, + { + "address": "0x140008d6c", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x140008d6f", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x140008d72", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140008d74", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r13 + 0x1c], eax" + }, + { + "address": "0x140008d78", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r13 + 8], rdx" + }, + { + "address": "0x140008d7c", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140008d7f", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140008d82", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x140008d8b", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140008d93", + "size": 3, + "mnemonic": "sub", + "operands": "r10, rax" + }, + { + "address": "0x140008d96", + "size": 3, + "mnemonic": "sub", + "operands": "r10, r8" + }, + { + "address": "0x140008d99", + "size": 3, + "mnemonic": "sub", + "operands": "r10, r9" + }, + { + "address": "0x140008d9c", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r10 - 4]" + }, + { + "address": "0x140008da0", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140008da2", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r13 + 0x20], eax" + }, + { + "address": "0x140008da6", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r10 + 4]" + }, + { + "address": "0x140008daa", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r13 + 8], r10" + }, + { + "address": "0x140008dae", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [r10]" + }, + { + "address": "0x140008db1", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r13 + 0x24], ecx" + }, + { + "address": "0x140008db5", + "size": 4, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rsp + 0x60]" + }, + { + "address": "0x140008db9", + "size": 2, + "mnemonic": "inc", + "operands": "ecx" + }, + { + "address": "0x140008dbb", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r13 + 8], rax" + }, + { + "address": "0x140008dbf", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x60], ecx" + }, + { + "address": "0x140008dc3", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, dword ptr [rbp - 0x58]" + }, + { + "address": "0x140008dc6", + "size": 6, + "mnemonic": "jb", + "operands": "0x140008c22" + } + ], + "successors": [ + "0x140008c22", + "0x140008dcc" + ] + }, + { + "address": "0x140008cb3", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008cb3", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140008cb8", + "size": 3, + "mnemonic": "add", + "operands": "rax, rbx" + }, + { + "address": "0x140008cbb", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140008cbf" + } + ], + "successors": [ + "0x140008cbf" + ] + }, + { + "address": "0x140008cbf", + "size": 63, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008cbf", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rax + 0x10], 0" + }, + { + "address": "0x140008cc3", + "size": 2, + "mnemonic": "jne", + "operands": "0x140008d19" + }, + { + "address": "0x140008cc5", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [rbp - 0x34], 0x40" + }, + { + "address": "0x140008cc9", + "size": 2, + "mnemonic": "jne", + "operands": "0x140008d19" + }, + { + "address": "0x140008ccb", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x68]" + }, + { + "address": "0x140008cd0", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rdi" + }, + { + "address": "0x140008cd3", + "size": 5, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140008cd8", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x140008cdb", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rbp - 0x78]" + }, + { + "address": "0x140008cdf", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x58], 0" + }, + { + "address": "0x140008ce4", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x50], 1" + }, + { + "address": "0x140008ce9", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x48], rax" + }, + { + "address": "0x140008cee", + "size": 5, + "mnemonic": "lea", + "operands": "rax, [rsp + 0x78]" + }, + { + "address": "0x140008cf3", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x40], r12d" + }, + { + "address": "0x140008cf8", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], rax" + }, + { + "address": "0x140008cfd", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp - 0x38]" + }, + { + "address": "0x140008d01", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], 0" + }, + { + "address": "0x140008d0a", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x140008d0f", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r15" + }, + { + "address": "0x140008d14", + "size": 5, + "mnemonic": "call", + "operands": "0x140007d88" + }, + { + "address": "0x140008d19", + "size": 7, + "mnemonic": "lea", + "operands": "r11, [rip - 0x8d20]" + }, + { + "address": "0x140008d20", + "size": 4, + "mnemonic": "mov", + "operands": "r10, qword ptr [r13 + 8]" + }, + { + "address": "0x140008d24", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r10" + }, + { + "address": "0x140008d27", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [r10]" + }, + { + "address": "0x140008d2b", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140008d2e", + "size": 9, + "mnemonic": "movsx", + "operands": "r9, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x140008d37", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140008d3f", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x140008d42", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x140008d45", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140008d47", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r13 + 8], rdx" + }, + { + "address": "0x140008d4b", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r13 + 0x18], eax" + }, + { + "address": "0x140008d4f", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140008d52", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r10" + }, + { + "address": "0x140008d55", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140008d58", + "size": 9, + "mnemonic": "movsx", + "operands": "r8, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x140008d61", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140008d69", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r8" + }, + { + "address": "0x140008d6c", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x140008d6f", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x140008d72", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140008d74", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r13 + 0x1c], eax" + }, + { + "address": "0x140008d78", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r13 + 8], rdx" + }, + { + "address": "0x140008d7c", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140008d7f", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140008d82", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x140008d8b", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140008d93", + "size": 3, + "mnemonic": "sub", + "operands": "r10, rax" + }, + { + "address": "0x140008d96", + "size": 3, + "mnemonic": "sub", + "operands": "r10, r8" + }, + { + "address": "0x140008d99", + "size": 3, + "mnemonic": "sub", + "operands": "r10, r9" + }, + { + "address": "0x140008d9c", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r10 - 4]" + }, + { + "address": "0x140008da0", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140008da2", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r13 + 0x20], eax" + }, + { + "address": "0x140008da6", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r10 + 4]" + }, + { + "address": "0x140008daa", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r13 + 8], r10" + }, + { + "address": "0x140008dae", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [r10]" + }, + { + "address": "0x140008db1", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r13 + 0x24], ecx" + }, + { + "address": "0x140008db5", + "size": 4, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rsp + 0x60]" + }, + { + "address": "0x140008db9", + "size": 2, + "mnemonic": "inc", + "operands": "ecx" + }, + { + "address": "0x140008dbb", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r13 + 8], rax" + }, + { + "address": "0x140008dbf", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x60], ecx" + }, + { + "address": "0x140008dc3", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, dword ptr [rbp - 0x58]" + }, + { + "address": "0x140008dc6", + "size": 6, + "mnemonic": "jb", + "operands": "0x140008c22" + } + ], + "successors": [ + "0x140008c22", + "0x140008dcc" + ] + } + ] + }, + { + "address": "0x14000a2fe", + "name": "", + "blocks": [ + { + "address": "0x14000a2fe", + "size": 12, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a2fe", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000a2ff", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x14000a300", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000a301", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x14000a303", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x14000a305", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000a307", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14000a309", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a30d", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rdx" + }, + { + "address": "0x14000a310", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rcx" + }, + { + "address": "0x14000a313", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14000a316", + "size": 6, + "mnemonic": "je", + "operands": "0x14000a3d5" + } + ], + "successors": [ + "0x14000a3d5", + "0x14000a31c" + ] + }, + { + "address": "0x14000a3d5", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a3d5", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x14000a3da", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000a31c", + "size": 38, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a31c", + "size": 3, + "mnemonic": "xor", + "operands": "r12b, r12b" + }, + { + "address": "0x14000a31f", + "size": 2, + "mnemonic": "xor", + "operands": "ebp, ebp" + }, + { + "address": "0x14000a321", + "size": 2, + "mnemonic": "cmp", + "operands": "dword ptr [rdx], ebp" + }, + { + "address": "0x14000a323", + "size": 6, + "mnemonic": "jle", + "operands": "0x14000a3bd" + }, + { + "address": "0x14000a329", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsi + 0x30]" + }, + { + "address": "0x14000a32d", + "size": 4, + "mnemonic": "movsxd", + "operands": "rdi, dword ptr [rax + 0xc]" + }, + { + "address": "0x14000a331", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x14000a336", + "size": 4, + "mnemonic": "add", + "operands": "rax, 4" + }, + { + "address": "0x14000a33a", + "size": 3, + "mnemonic": "add", + "operands": "rdi, rax" + }, + { + "address": "0x14000a33d", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsi + 0x30]" + }, + { + "address": "0x14000a341", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x68], rdi" + }, + { + "address": "0x14000a346", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rax + 0xc]" + }, + { + "address": "0x14000a34a", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x14000a34f", + "size": 4, + "mnemonic": "mov", + "operands": "r15d, dword ptr [rax + rbx]" + }, + { + "address": "0x14000a353", + "size": 3, + "mnemonic": "test", + "operands": "r15d, r15d" + }, + { + "address": "0x14000a356", + "size": 2, + "mnemonic": "jle", + "operands": "0x14000a3b2" + }, + { + "address": "0x14000a358", + "size": 3, + "mnemonic": "movsxd", + "operands": "rax, ebp" + }, + { + "address": "0x14000a35b", + "size": 4, + "mnemonic": "lea", + "operands": "r13, [rax + rax*4]" + }, + { + "address": "0x14000a35f", + "size": 3, + "mnemonic": "movsxd", + "operands": "rsi, dword ptr [rdi]" + }, + { + "address": "0x14000a362", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x14000a367", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [r14 + 4]" + }, + { + "address": "0x14000a36b", + "size": 3, + "mnemonic": "add", + "operands": "rsi, rax" + }, + { + "address": "0x14000a36e", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14000a373", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rax + 0x30]" + }, + { + "address": "0x14000a377", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x14000a37c", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rdi" + }, + { + "address": "0x14000a37f", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x14000a382", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + r13*4]" + }, + { + "address": "0x14000a386", + "size": 3, + "mnemonic": "add", + "operands": "rcx, rbx" + }, + { + "address": "0x14000a389", + "size": 5, + "mnemonic": "call", + "operands": "0x140008df4" + }, + { + "address": "0x14000a38e", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000a390", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000a3aa" + }, + { + "address": "0x14000a392", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x68]" + }, + { + "address": "0x14000a397", + "size": 3, + "mnemonic": "dec", + "operands": "r15d" + }, + { + "address": "0x14000a39a", + "size": 4, + "mnemonic": "add", + "operands": "rdi, 4" + }, + { + "address": "0x14000a39e", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x68], rdi" + }, + { + "address": "0x14000a3a3", + "size": 3, + "mnemonic": "test", + "operands": "r15d, r15d" + }, + { + "address": "0x14000a3a6", + "size": 2, + "mnemonic": "jg", + "operands": "0x14000a35f" + } + ], + "successors": [ + "0x14000a35f", + "0x14000a3a8" + ] + }, + { + "address": "0x14000a35f", + "size": 20, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a35f", + "size": 3, + "mnemonic": "movsxd", + "operands": "rsi, dword ptr [rdi]" + }, + { + "address": "0x14000a362", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x14000a367", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [r14 + 4]" + }, + { + "address": "0x14000a36b", + "size": 3, + "mnemonic": "add", + "operands": "rsi, rax" + }, + { + "address": "0x14000a36e", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14000a373", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rax + 0x30]" + }, + { + "address": "0x14000a377", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x14000a37c", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rdi" + }, + { + "address": "0x14000a37f", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x14000a382", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + r13*4]" + }, + { + "address": "0x14000a386", + "size": 3, + "mnemonic": "add", + "operands": "rcx, rbx" + }, + { + "address": "0x14000a389", + "size": 5, + "mnemonic": "call", + "operands": "0x140008df4" + }, + { + "address": "0x14000a38e", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000a390", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000a3aa" + }, + { + "address": "0x14000a392", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x68]" + }, + { + "address": "0x14000a397", + "size": 3, + "mnemonic": "dec", + "operands": "r15d" + }, + { + "address": "0x14000a39a", + "size": 4, + "mnemonic": "add", + "operands": "rdi, 4" + }, + { + "address": "0x14000a39e", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x68], rdi" + }, + { + "address": "0x14000a3a3", + "size": 3, + "mnemonic": "test", + "operands": "r15d, r15d" + }, + { + "address": "0x14000a3a6", + "size": 2, + "mnemonic": "jg", + "operands": "0x14000a35f" + } + ], + "successors": [ + "0x14000a35f", + "0x14000a3a8" + ] + }, + { + "address": "0x14000a3a8", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a3a8", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000a3ad" + } + ], + "successors": [ + "0x14000a3ad" + ] + }, + { + "address": "0x14000a3ad", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a3ad", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14000a3b2", + "size": 2, + "mnemonic": "inc", + "operands": "ebp" + }, + { + "address": "0x14000a3b4", + "size": 3, + "mnemonic": "cmp", + "operands": "ebp, dword ptr [r14]" + }, + { + "address": "0x14000a3b7", + "size": 6, + "mnemonic": "jl", + "operands": "0x14000a329" + } + ], + "successors": [ + "0x14000a329", + "0x14000a3bd" + ] + }, + { + "address": "0x14000a329", + "size": 34, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a329", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsi + 0x30]" + }, + { + "address": "0x14000a32d", + "size": 4, + "mnemonic": "movsxd", + "operands": "rdi, dword ptr [rax + 0xc]" + }, + { + "address": "0x14000a331", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x14000a336", + "size": 4, + "mnemonic": "add", + "operands": "rax, 4" + }, + { + "address": "0x14000a33a", + "size": 3, + "mnemonic": "add", + "operands": "rdi, rax" + }, + { + "address": "0x14000a33d", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsi + 0x30]" + }, + { + "address": "0x14000a341", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x68], rdi" + }, + { + "address": "0x14000a346", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rax + 0xc]" + }, + { + "address": "0x14000a34a", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x14000a34f", + "size": 4, + "mnemonic": "mov", + "operands": "r15d, dword ptr [rax + rbx]" + }, + { + "address": "0x14000a353", + "size": 3, + "mnemonic": "test", + "operands": "r15d, r15d" + }, + { + "address": "0x14000a356", + "size": 2, + "mnemonic": "jle", + "operands": "0x14000a3b2" + }, + { + "address": "0x14000a358", + "size": 3, + "mnemonic": "movsxd", + "operands": "rax, ebp" + }, + { + "address": "0x14000a35b", + "size": 4, + "mnemonic": "lea", + "operands": "r13, [rax + rax*4]" + }, + { + "address": "0x14000a35f", + "size": 3, + "mnemonic": "movsxd", + "operands": "rsi, dword ptr [rdi]" + }, + { + "address": "0x14000a362", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x14000a367", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [r14 + 4]" + }, + { + "address": "0x14000a36b", + "size": 3, + "mnemonic": "add", + "operands": "rsi, rax" + }, + { + "address": "0x14000a36e", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14000a373", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rax + 0x30]" + }, + { + "address": "0x14000a377", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x14000a37c", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rdi" + }, + { + "address": "0x14000a37f", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x14000a382", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + r13*4]" + }, + { + "address": "0x14000a386", + "size": 3, + "mnemonic": "add", + "operands": "rcx, rbx" + }, + { + "address": "0x14000a389", + "size": 5, + "mnemonic": "call", + "operands": "0x140008df4" + }, + { + "address": "0x14000a38e", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000a390", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000a3aa" + }, + { + "address": "0x14000a392", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x68]" + }, + { + "address": "0x14000a397", + "size": 3, + "mnemonic": "dec", + "operands": "r15d" + }, + { + "address": "0x14000a39a", + "size": 4, + "mnemonic": "add", + "operands": "rdi, 4" + }, + { + "address": "0x14000a39e", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x68], rdi" + }, + { + "address": "0x14000a3a3", + "size": 3, + "mnemonic": "test", + "operands": "r15d, r15d" + }, + { + "address": "0x14000a3a6", + "size": 2, + "mnemonic": "jg", + "operands": "0x14000a35f" + } + ], + "successors": [ + "0x14000a35f", + "0x14000a3a8" + ] + }, + { + "address": "0x14000a3bd", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000a3bd", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x70]" + }, + { + "address": "0x14000a3c2", + "size": 3, + "mnemonic": "mov", + "operands": "al, r12b" + }, + { + "address": "0x14000a3c5", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a3c9", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000a3cb", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000a3cd", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14000a3cf", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14000a3d1", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000a3d2", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14000a3d3", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000a3d4", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000a52f", + "name": "", + "blocks": [ + { + "address": "0x14000a52f", + "size": 31, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a52f", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000a530", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x14000a531", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000a532", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x14000a534", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x14000a536", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000a538", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14000a53a", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a53e", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 8]" + }, + { + "address": "0x14000a542", + "size": 3, + "mnemonic": "xor", + "operands": "bpl, bpl" + }, + { + "address": "0x14000a545", + "size": 3, + "mnemonic": "xor", + "operands": "r14b, r14b" + }, + { + "address": "0x14000a548", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r11 + 8], rax" + }, + { + "address": "0x14000a54c", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x14000a54e", + "size": 3, + "mnemonic": "mov", + "operands": "r12, r9" + }, + { + "address": "0x14000a551", + "size": 3, + "mnemonic": "mov", + "operands": "r13d, r8d" + }, + { + "address": "0x14000a554", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14000a557", + "size": 4, + "mnemonic": "lea", + "operands": "rsi, [rax - 1]" + }, + { + "address": "0x14000a55b", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rsi" + }, + { + "address": "0x14000a55e", + "size": 2, + "mnemonic": "cmp", + "operands": "dword ptr [rcx], edi" + }, + { + "address": "0x14000a560", + "size": 2, + "mnemonic": "jle", + "operands": "0x14000a5a5" + }, + { + "address": "0x14000a562", + "size": 4, + "mnemonic": "mov", + "operands": "r12d, dword ptr [r11 + 0x10]" + }, + { + "address": "0x14000a566", + "size": 3, + "mnemonic": "cmp", + "operands": "edi, r12d" + }, + { + "address": "0x14000a569", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000a571" + }, + { + "address": "0x14000a56b", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rax" + }, + { + "address": "0x14000a56e", + "size": 3, + "mnemonic": "mov", + "operands": "bpl, 1" + }, + { + "address": "0x14000a571", + "size": 3, + "mnemonic": "cmp", + "operands": "edi, r13d" + }, + { + "address": "0x14000a574", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000a57c" + }, + { + "address": "0x14000a576", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rax" + }, + { + "address": "0x14000a579", + "size": 3, + "mnemonic": "mov", + "operands": "r14b, 1" + }, + { + "address": "0x14000a57c", + "size": 3, + "mnemonic": "test", + "operands": "bpl, bpl" + }, + { + "address": "0x14000a57f", + "size": 2, + "mnemonic": "je", + "operands": "0x14000a586" + } + ], + "successors": [ + "0x14000a586", + "0x14000a581" + ] + }, + { + "address": "0x14000a586", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a586", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x60]" + }, + { + "address": "0x14000a58b", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x14000a58e", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a464" + }, + { + "address": "0x14000a593", + "size": 2, + "mnemonic": "inc", + "operands": "edi" + }, + { + "address": "0x14000a595", + "size": 2, + "mnemonic": "cmp", + "operands": "edi, dword ptr [rbx]" + }, + { + "address": "0x14000a597", + "size": 2, + "mnemonic": "jge", + "operands": "0x14000a5a0" + }, + { + "address": "0x14000a599", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14000a59e", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000a566" + } + ], + "successors": [ + "0x14000a566" + ] + }, + { + "address": "0x14000a581", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a581", + "size": 3, + "mnemonic": "test", + "operands": "r14b, r14b" + }, + { + "address": "0x14000a584", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000a5a0" + }, + { + "address": "0x14000a586", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x60]" + }, + { + "address": "0x14000a58b", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x14000a58e", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a464" + }, + { + "address": "0x14000a593", + "size": 2, + "mnemonic": "inc", + "operands": "edi" + }, + { + "address": "0x14000a595", + "size": 2, + "mnemonic": "cmp", + "operands": "edi, dword ptr [rbx]" + }, + { + "address": "0x14000a597", + "size": 2, + "mnemonic": "jge", + "operands": "0x14000a5a0" + }, + { + "address": "0x14000a599", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14000a59e", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000a566" + } + ], + "successors": [ + "0x14000a566" + ] + }, + { + "address": "0x14000a566", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a566", + "size": 3, + "mnemonic": "cmp", + "operands": "edi, r12d" + }, + { + "address": "0x14000a569", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000a571" + }, + { + "address": "0x14000a56b", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rax" + }, + { + "address": "0x14000a56e", + "size": 3, + "mnemonic": "mov", + "operands": "bpl, 1" + }, + { + "address": "0x14000a571", + "size": 3, + "mnemonic": "cmp", + "operands": "edi, r13d" + }, + { + "address": "0x14000a574", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000a57c" + }, + { + "address": "0x14000a576", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rax" + }, + { + "address": "0x14000a579", + "size": 3, + "mnemonic": "mov", + "operands": "r14b, 1" + }, + { + "address": "0x14000a57c", + "size": 3, + "mnemonic": "test", + "operands": "bpl, bpl" + }, + { + "address": "0x14000a57f", + "size": 2, + "mnemonic": "je", + "operands": "0x14000a586" + } + ], + "successors": [ + "0x14000a586", + "0x14000a581" + ] + } + ] + }, + { + "address": "0x14000acf2", + "name": "", + "blocks": [ + { + "address": "0x14000acf2", + "size": 13, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000acf2", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000acf3", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000acf4", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000acf6", + "size": 8, + "mnemonic": "lea", + "operands": "rbp, [rsp - 0x4f0]" + }, + { + "address": "0x14000acfe", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x5f0" + }, + { + "address": "0x14000ad05", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x26334]" + }, + { + "address": "0x14000ad0c", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x14000ad0f", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x4e0], rax" + }, + { + "address": "0x14000ad16", + "size": 3, + "mnemonic": "mov", + "operands": "edi, r8d" + }, + { + "address": "0x14000ad19", + "size": 2, + "mnemonic": "mov", + "operands": "esi, edx" + }, + { + "address": "0x14000ad1b", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, ecx" + }, + { + "address": "0x14000ad1d", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, -1" + }, + { + "address": "0x14000ad20", + "size": 2, + "mnemonic": "je", + "operands": "0x14000ad27" + } + ], + "successors": [ + "0x14000ad27", + "0x14000ad22" + ] + }, + { + "address": "0x14000ad27", + "size": 24, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ad27", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000ad29", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x70]" + }, + { + "address": "0x14000ad2e", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x98" + }, + { + "address": "0x14000ad34", + "size": 5, + "mnemonic": "call", + "operands": "0x14001ea80" + }, + { + "address": "0x14000ad39", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000ad3b", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x10]" + }, + { + "address": "0x14000ad3f", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x4d0" + }, + { + "address": "0x14000ad45", + "size": 5, + "mnemonic": "call", + "operands": "0x14001ea80" + }, + { + "address": "0x14000ad4a", + "size": 6, + "mnemonic": "and", + "operands": "qword ptr [rsp + 0x48], 0" + }, + { + "address": "0x14000ad50", + "size": 5, + "mnemonic": "lea", + "operands": "rax, [rsp + 0x70]" + }, + { + "address": "0x14000ad55", + "size": 6, + "mnemonic": "and", + "operands": "qword ptr [rsp + 0x40], 0" + }, + { + "address": "0x14000ad5b", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x10]" + }, + { + "address": "0x14000ad5f", + "size": 6, + "mnemonic": "and", + "operands": "qword ptr [rsp + 0x50], 0" + }, + { + "address": "0x14000ad65", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x58], rax" + }, + { + "address": "0x14000ad6a", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x10]" + }, + { + "address": "0x14000ad6e", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x60], rax" + }, + { + "address": "0x14000ad73", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x152df]" + }, + { + "address": "0x14000ad79", + "size": 7, + "mnemonic": "mov", + "operands": "r14, qword ptr [rbp + 0x108]" + }, + { + "address": "0x14000ad80", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x40]" + }, + { + "address": "0x14000ad85", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r14" + }, + { + "address": "0x14000ad88", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x14000ad8b", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x152cf]" + }, + { + "address": "0x14000ad91", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000ad94", + "size": 2, + "mnemonic": "je", + "operands": "0x14000adcc" + } + ], + "successors": [ + "0x14000adcc", + "0x14000ad96" + ] + }, + { + "address": "0x14000ad22", + "size": 25, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ad22", + "size": 5, + "mnemonic": "call", + "operands": "0x140005e38" + }, + { + "address": "0x14000ad27", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000ad29", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x70]" + }, + { + "address": "0x14000ad2e", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x98" + }, + { + "address": "0x14000ad34", + "size": 5, + "mnemonic": "call", + "operands": "0x14001ea80" + }, + { + "address": "0x14000ad39", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000ad3b", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x10]" + }, + { + "address": "0x14000ad3f", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x4d0" + }, + { + "address": "0x14000ad45", + "size": 5, + "mnemonic": "call", + "operands": "0x14001ea80" + }, + { + "address": "0x14000ad4a", + "size": 6, + "mnemonic": "and", + "operands": "qword ptr [rsp + 0x48], 0" + }, + { + "address": "0x14000ad50", + "size": 5, + "mnemonic": "lea", + "operands": "rax, [rsp + 0x70]" + }, + { + "address": "0x14000ad55", + "size": 6, + "mnemonic": "and", + "operands": "qword ptr [rsp + 0x40], 0" + }, + { + "address": "0x14000ad5b", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x10]" + }, + { + "address": "0x14000ad5f", + "size": 6, + "mnemonic": "and", + "operands": "qword ptr [rsp + 0x50], 0" + }, + { + "address": "0x14000ad65", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x58], rax" + }, + { + "address": "0x14000ad6a", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x10]" + }, + { + "address": "0x14000ad6e", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x60], rax" + }, + { + "address": "0x14000ad73", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x152df]" + }, + { + "address": "0x14000ad79", + "size": 7, + "mnemonic": "mov", + "operands": "r14, qword ptr [rbp + 0x108]" + }, + { + "address": "0x14000ad80", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x40]" + }, + { + "address": "0x14000ad85", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r14" + }, + { + "address": "0x14000ad88", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x14000ad8b", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x152cf]" + }, + { + "address": "0x14000ad91", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000ad94", + "size": 2, + "mnemonic": "je", + "operands": "0x14000adcc" + } + ], + "successors": [ + "0x14000adcc", + "0x14000ad96" + ] + }, + { + "address": "0x14000adcc", + "size": 21, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000adcc", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x508]" + }, + { + "address": "0x14000add3", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x108], rax" + }, + { + "address": "0x14000adda", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x508]" + }, + { + "address": "0x14000ade1", + "size": 4, + "mnemonic": "add", + "operands": "rax, 8" + }, + { + "address": "0x14000ade5", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x70], esi" + }, + { + "address": "0x14000ade9", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0xa8], rax" + }, + { + "address": "0x14000adf0", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x508]" + }, + { + "address": "0x14000adf7", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x80], rax" + }, + { + "address": "0x14000adfb", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x74], edi" + }, + { + "address": "0x14000adff", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x152bb]" + }, + { + "address": "0x14000ae05", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14000ae07", + "size": 2, + "mnemonic": "mov", + "operands": "edi, eax" + }, + { + "address": "0x14000ae09", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x15269]" + }, + { + "address": "0x14000ae0f", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x58]" + }, + { + "address": "0x14000ae14", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x15256]" + }, + { + "address": "0x14000ae1a", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000ae1c", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000ae2e" + }, + { + "address": "0x14000ae1e", + "size": 2, + "mnemonic": "test", + "operands": "edi, edi" + }, + { + "address": "0x14000ae20", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000ae2e" + }, + { + "address": "0x14000ae22", + "size": 3, + "mnemonic": "cmp", + "operands": "ebx, -1" + }, + { + "address": "0x14000ae25", + "size": 2, + "mnemonic": "je", + "operands": "0x14000ae2e" + } + ], + "successors": [ + "0x14000ae2e", + "0x14000ae27" + ] + }, + { + "address": "0x14000ad96", + "size": 33, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ad96", + "size": 6, + "mnemonic": "and", + "operands": "qword ptr [rsp + 0x38], 0" + }, + { + "address": "0x14000ad9c", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x48]" + }, + { + "address": "0x14000ada1", + "size": 5, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14000ada6", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rax" + }, + { + "address": "0x14000ada9", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rcx" + }, + { + "address": "0x14000adae", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x14000adb1", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x50]" + }, + { + "address": "0x14000adb6", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rcx" + }, + { + "address": "0x14000adbb", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x10]" + }, + { + "address": "0x14000adbf", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rcx" + }, + { + "address": "0x14000adc4", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14000adc6", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1529c]" + }, + { + "address": "0x14000adcc", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x508]" + }, + { + "address": "0x14000add3", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x108], rax" + }, + { + "address": "0x14000adda", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x508]" + }, + { + "address": "0x14000ade1", + "size": 4, + "mnemonic": "add", + "operands": "rax, 8" + }, + { + "address": "0x14000ade5", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x70], esi" + }, + { + "address": "0x14000ade9", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0xa8], rax" + }, + { + "address": "0x14000adf0", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x508]" + }, + { + "address": "0x14000adf7", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x80], rax" + }, + { + "address": "0x14000adfb", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x74], edi" + }, + { + "address": "0x14000adff", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x152bb]" + }, + { + "address": "0x14000ae05", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14000ae07", + "size": 2, + "mnemonic": "mov", + "operands": "edi, eax" + }, + { + "address": "0x14000ae09", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x15269]" + }, + { + "address": "0x14000ae0f", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x58]" + }, + { + "address": "0x14000ae14", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x15256]" + }, + { + "address": "0x14000ae1a", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000ae1c", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000ae2e" + }, + { + "address": "0x14000ae1e", + "size": 2, + "mnemonic": "test", + "operands": "edi, edi" + }, + { + "address": "0x14000ae20", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000ae2e" + }, + { + "address": "0x14000ae22", + "size": 3, + "mnemonic": "cmp", + "operands": "ebx, -1" + }, + { + "address": "0x14000ae25", + "size": 2, + "mnemonic": "je", + "operands": "0x14000ae2e" + } + ], + "successors": [ + "0x14000ae2e", + "0x14000ae27" + ] + }, + { + "address": "0x14000ae2e", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000ae2e", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x4e0]" + }, + { + "address": "0x14000ae35", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x14000ae38", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x14000ae3d", + "size": 8, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x5f0]" + }, + { + "address": "0x14000ae45", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x28]" + }, + { + "address": "0x14000ae49", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x30]" + }, + { + "address": "0x14000ae4d", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x14000ae50", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000ae52", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000ae53", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000ae54", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000ae27", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000ae27", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x14000ae29", + "size": 5, + "mnemonic": "call", + "operands": "0x140005e38" + }, + { + "address": "0x14000ae2e", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x4e0]" + }, + { + "address": "0x14000ae35", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x14000ae38", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x14000ae3d", + "size": 8, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x5f0]" + }, + { + "address": "0x14000ae45", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x28]" + }, + { + "address": "0x14000ae49", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x30]" + }, + { + "address": "0x14000ae4d", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x14000ae50", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000ae52", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000ae53", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000ae54", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000ae65", + "name": "", + "blocks": [ + { + "address": "0x14000ae65", + "size": 24, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ae65", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000ae66", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14000ae69", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x70" + }, + { + "address": "0x14000ae6d", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rbp - 0x40], 0" + }, + { + "address": "0x14000ae72", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x28377], 0" + }, + { + "address": "0x14000ae79", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x30], 0" + }, + { + "address": "0x14000ae7d", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 0" + }, + { + "address": "0x14000ae81", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x14000ae85", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x14000ae89", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000ae9b" + }, + { + "address": "0x14000ae8b", + "size": 7, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rip + 0x26596]" + }, + { + "address": "0x14000ae92", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 1" + }, + { + "address": "0x14000ae96", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp - 0x28], xmm0" + }, + { + "address": "0x14000ae9b", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp - 0x40]" + }, + { + "address": "0x14000ae9f", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x14000aea4", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x30]" + }, + { + "address": "0x14000aea8", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14000aead", + "size": 5, + "mnemonic": "call", + "operands": "0x14000aefc" + }, + { + "address": "0x14000aeb2", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x18], 2" + }, + { + "address": "0x14000aeb6", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000aec3" + }, + { + "address": "0x14000aeb8", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp - 0x40]" + }, + { + "address": "0x14000aebc", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rax + 0x3a8], 0xfffffffd" + }, + { + "address": "0x14000aec3", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x14000aec7", + "size": 2, + "mnemonic": "je", + "operands": "0x14000aed8" + } + ], + "successors": [ + "0x14000aed8", + "0x14000aec9" + ] + }, + { + "address": "0x14000aed8", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000aed8", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x14000aedc", + "size": 2, + "mnemonic": "je", + "operands": "0x14000aeed" + } + ], + "successors": [ + "0x14000aeed", + "0x14000aede" + ] + }, + { + "address": "0x14000aec9", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000aec9", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0x14]" + }, + { + "address": "0x14000aecc", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x14000aed0", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x14000aed5", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x20], ebx" + }, + { + "address": "0x14000aed8", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x14000aedc", + "size": 2, + "mnemonic": "je", + "operands": "0x14000aeed" + } + ], + "successors": [ + "0x14000aeed", + "0x14000aede" + ] + }, + { + "address": "0x14000aeed", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000aeed", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x80]" + }, + { + "address": "0x14000aef5", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x70" + }, + { + "address": "0x14000aef9", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000aefa", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000aede", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000aede", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0xc]" + }, + { + "address": "0x14000aee1", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x14000aee5", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x14000aeea", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x24], ebx" + }, + { + "address": "0x14000aeed", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x80]" + }, + { + "address": "0x14000aef5", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x70" + }, + { + "address": "0x14000aef9", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000aefa", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000b33e", + "name": "", + "blocks": [ + { + "address": "0x14000b33e", + "size": 22, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b33e", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000b33f", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14000b342", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x14000b346", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rbp - 0x40], 0" + }, + { + "address": "0x14000b34b", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x27e9e], 0" + }, + { + "address": "0x14000b352", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x30], 0" + }, + { + "address": "0x14000b356", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 0" + }, + { + "address": "0x14000b35a", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x14000b35e", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x14000b362", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000b374" + }, + { + "address": "0x14000b364", + "size": 7, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rip + 0x260bd]" + }, + { + "address": "0x14000b36b", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 1" + }, + { + "address": "0x14000b36f", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp - 0x28], xmm0" + }, + { + "address": "0x14000b374", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x40]" + }, + { + "address": "0x14000b378", + "size": 5, + "mnemonic": "call", + "operands": "0x14000b210" + }, + { + "address": "0x14000b37d", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x18], 2" + }, + { + "address": "0x14000b381", + "size": 2, + "mnemonic": "mov", + "operands": "edi, eax" + }, + { + "address": "0x14000b383", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000b390" + }, + { + "address": "0x14000b385", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x40]" + }, + { + "address": "0x14000b389", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rcx + 0x3a8], 0xfffffffd" + }, + { + "address": "0x14000b390", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x14000b394", + "size": 2, + "mnemonic": "je", + "operands": "0x14000b3a5" + } + ], + "successors": [ + "0x14000b3a5", + "0x14000b396" + ] + }, + { + "address": "0x14000b3a5", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b3a5", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x14000b3a9", + "size": 2, + "mnemonic": "je", + "operands": "0x14000b3ba" + } + ], + "successors": [ + "0x14000b3ba", + "0x14000b3ab" + ] + }, + { + "address": "0x14000b396", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b396", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0x14]" + }, + { + "address": "0x14000b399", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x14000b39d", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x14000b3a2", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x20], ebx" + }, + { + "address": "0x14000b3a5", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x14000b3a9", + "size": 2, + "mnemonic": "je", + "operands": "0x14000b3ba" + } + ], + "successors": [ + "0x14000b3ba", + "0x14000b3ab" + ] + }, + { + "address": "0x14000b3ba", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000b3ba", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x70]" + }, + { + "address": "0x14000b3bf", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x14000b3c1", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x78]" + }, + { + "address": "0x14000b3c6", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x14000b3ca", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000b3cb", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000b3ab", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000b3ab", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0xc]" + }, + { + "address": "0x14000b3ae", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x14000b3b2", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x14000b3b7", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x24], ebx" + }, + { + "address": "0x14000b3ba", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x70]" + }, + { + "address": "0x14000b3bf", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x14000b3c1", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x78]" + }, + { + "address": "0x14000b3c6", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x14000b3ca", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000b3cb", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000b590", + "name": "", + "blocks": [ + { + "address": "0x14000b590", + "size": 25, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000b590", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000b591", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14000b594", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x14000b598", + "size": 4, + "mnemonic": "and", + "operands": "dword ptr [rbp + 0x28], 0" + }, + { + "address": "0x14000b59c", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x28]" + }, + { + "address": "0x14000b5a0", + "size": 4, + "mnemonic": "and", + "operands": "dword ptr [rbp + 0x20], 0" + }, + { + "address": "0x14000b5a4", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp - 0x20]" + }, + { + "address": "0x14000b5a8", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x18], rax" + }, + { + "address": "0x14000b5ac", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbp - 0x18]" + }, + { + "address": "0x14000b5b0", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x10]" + }, + { + "address": "0x14000b5b4", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x10], rax" + }, + { + "address": "0x14000b5b8", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x1c]" + }, + { + "address": "0x14000b5bc", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x20]" + }, + { + "address": "0x14000b5c0", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 8], rax" + }, + { + "address": "0x14000b5c4", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x18]" + }, + { + "address": "0x14000b5c8", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 8" + }, + { + "address": "0x14000b5cd", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x20], eax" + }, + { + "address": "0x14000b5d0", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x1c], eax" + }, + { + "address": "0x14000b5d3", + "size": 5, + "mnemonic": "call", + "operands": "0x14000b468" + }, + { + "address": "0x14000b5d8", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp + 0x10], 0" + }, + { + "address": "0x14000b5dc", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbp + 0x20]" + }, + { + "address": "0x14000b5df", + "size": 4, + "mnemonic": "cmovne", + "operands": "eax, dword ptr [rbp + 0x28]" + }, + { + "address": "0x14000b5e3", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x40" + }, + { + "address": "0x14000b5e7", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000b5e8", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000b682", + "name": "", + "blocks": [ + { + "address": "0x14000b682", + "size": 20, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b682", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000b683", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14000b686", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x14000b68a", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rbp - 0x40], 0" + }, + { + "address": "0x14000b68f", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14000b692", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x27b57], 0" + }, + { + "address": "0x14000b699", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x30], 0" + }, + { + "address": "0x14000b69d", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 0" + }, + { + "address": "0x14000b6a1", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x14000b6a5", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x14000b6a9", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000b6bb" + }, + { + "address": "0x14000b6ab", + "size": 7, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rip + 0x25d76]" + }, + { + "address": "0x14000b6b2", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 1" + }, + { + "address": "0x14000b6b6", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp - 0x28], xmm0" + }, + { + "address": "0x14000b6bb", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x14000b6be", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000b6cb" + }, + { + "address": "0x14000b6c0", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14000b6c2", + "size": 5, + "mnemonic": "call", + "operands": "0x14000b58c" + }, + { + "address": "0x14000b6c7", + "size": 2, + "mnemonic": "mov", + "operands": "edi, eax" + }, + { + "address": "0x14000b6c9", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000b6fd" + } + ], + "successors": [ + "0x14000b6fd" + ] + }, + { + "address": "0x14000b6fd", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b6fd", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x18], 2" + }, + { + "address": "0x14000b701", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000b70e" + }, + { + "address": "0x14000b703", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp - 0x40]" + }, + { + "address": "0x14000b707", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rax + 0x3a8], 0xfffffffd" + }, + { + "address": "0x14000b70e", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x14000b712", + "size": 2, + "mnemonic": "je", + "operands": "0x14000b723" + } + ], + "successors": [ + "0x14000b723", + "0x14000b714" + ] + }, + { + "address": "0x14000b723", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b723", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x14000b727", + "size": 2, + "mnemonic": "je", + "operands": "0x14000b738" + } + ], + "successors": [ + "0x14000b738", + "0x14000b729" + ] + }, + { + "address": "0x14000b714", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b714", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0x14]" + }, + { + "address": "0x14000b717", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x14000b71b", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x14000b720", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x20], ebx" + }, + { + "address": "0x14000b723", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x14000b727", + "size": 2, + "mnemonic": "je", + "operands": "0x14000b738" + } + ], + "successors": [ + "0x14000b738", + "0x14000b729" + ] + }, + { + "address": "0x14000b738", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000b738", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x70]" + }, + { + "address": "0x14000b73d", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x14000b73f", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x78]" + }, + { + "address": "0x14000b744", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x14000b748", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000b749", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000b729", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000b729", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0xc]" + }, + { + "address": "0x14000b72c", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x14000b730", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x14000b735", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x24], ebx" + }, + { + "address": "0x14000b738", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x70]" + }, + { + "address": "0x14000b73d", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x14000b73f", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x78]" + }, + { + "address": "0x14000b744", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x14000b748", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000b749", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000bace", + "name": "", + "blocks": [ + { + "address": "0x14000bace", + "size": 22, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000bace", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000bacf", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14000bad2", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x14000bad6", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rbp - 0x40], 0" + }, + { + "address": "0x14000badb", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x2770e], 0" + }, + { + "address": "0x14000bae2", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x30], 0" + }, + { + "address": "0x14000bae6", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 0" + }, + { + "address": "0x14000baea", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x14000baee", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x14000baf2", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000bb04" + }, + { + "address": "0x14000baf4", + "size": 7, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rip + 0x2592d]" + }, + { + "address": "0x14000bafb", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 1" + }, + { + "address": "0x14000baff", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp - 0x28], xmm0" + }, + { + "address": "0x14000bb04", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbp - 0x40]" + }, + { + "address": "0x14000bb08", + "size": 5, + "mnemonic": "call", + "operands": "0x14000b960" + }, + { + "address": "0x14000bb0d", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x18], 2" + }, + { + "address": "0x14000bb11", + "size": 2, + "mnemonic": "mov", + "operands": "edi, eax" + }, + { + "address": "0x14000bb13", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000bb20" + }, + { + "address": "0x14000bb15", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x40]" + }, + { + "address": "0x14000bb19", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rcx + 0x3a8], 0xfffffffd" + }, + { + "address": "0x14000bb20", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x14000bb24", + "size": 2, + "mnemonic": "je", + "operands": "0x14000bb35" + } + ], + "successors": [ + "0x14000bb35", + "0x14000bb26" + ] + }, + { + "address": "0x14000bb35", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000bb35", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x14000bb39", + "size": 2, + "mnemonic": "je", + "operands": "0x14000bb4a" + } + ], + "successors": [ + "0x14000bb4a", + "0x14000bb3b" + ] + }, + { + "address": "0x14000bb26", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000bb26", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0x14]" + }, + { + "address": "0x14000bb29", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x14000bb2d", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x14000bb32", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x20], ebx" + }, + { + "address": "0x14000bb35", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x14000bb39", + "size": 2, + "mnemonic": "je", + "operands": "0x14000bb4a" + } + ], + "successors": [ + "0x14000bb4a", + "0x14000bb3b" + ] + }, + { + "address": "0x14000bb4a", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000bb4a", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x70]" + }, + { + "address": "0x14000bb4f", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x14000bb51", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x78]" + }, + { + "address": "0x14000bb56", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x14000bb5a", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000bb5b", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000bb3b", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000bb3b", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0xc]" + }, + { + "address": "0x14000bb3e", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x14000bb42", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x14000bb47", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x24], ebx" + }, + { + "address": "0x14000bb4a", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x70]" + }, + { + "address": "0x14000bb4f", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x14000bb51", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x78]" + }, + { + "address": "0x14000bb56", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x14000bb5a", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000bb5b", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000bb66", + "name": "", + "blocks": [ + { + "address": "0x14000bb66", + "size": 14, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000bb66", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000bb67", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x14000bb68", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000bb69", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x14000bb6b", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x14000bb6d", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000bb6f", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14000bb71", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000bb75", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x80]" + }, + { + "address": "0x14000bb7d", + "size": 3, + "mnemonic": "mov", + "operands": "r15, r8" + }, + { + "address": "0x14000bb80", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rdx" + }, + { + "address": "0x14000bb83", + "size": 3, + "mnemonic": "mov", + "operands": "r12, rcx" + }, + { + "address": "0x14000bb86", + "size": 3, + "mnemonic": "test", + "operands": "r8, r8" + }, + { + "address": "0x14000bb89", + "size": 2, + "mnemonic": "je", + "operands": "0x14000bba5" + } + ], + "successors": [ + "0x14000bba5", + "0x14000bb8b" + ] + }, + { + "address": "0x14000bba5", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000bba5", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000bba7", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14000bbac", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000bbb0", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000bbb2", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000bbb4", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14000bbb6", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14000bbb8", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000bbb9", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14000bbba", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000bbbb", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000bb8b", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000bb8b", + "size": 3, + "mnemonic": "test", + "operands": "r9, r9" + }, + { + "address": "0x14000bb8e", + "size": 2, + "mnemonic": "je", + "operands": "0x14000bba5" + } + ], + "successors": [ + "0x14000bba5", + "0x14000bb90" + ] + }, + { + "address": "0x14000bb90", + "size": 16, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000bb90", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14000bb93", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000bbbc" + }, + { + "address": "0x14000bb95", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x14000bb9a", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0x16" + }, + { + "address": "0x14000bba0", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afb4" + }, + { + "address": "0x14000bba5", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000bba7", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14000bbac", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000bbb0", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000bbb2", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000bbb4", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14000bbb6", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14000bbb8", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000bbb9", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14000bbba", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000bbbb", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000c156", + "name": "", + "blocks": [ + { + "address": "0x14000c156", + "size": 22, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000c156", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000c157", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14000c15a", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x14000c15e", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rbp - 0x40], 0" + }, + { + "address": "0x14000c163", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x27086], 0" + }, + { + "address": "0x14000c16a", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x30], 0" + }, + { + "address": "0x14000c16e", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 0" + }, + { + "address": "0x14000c172", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x14000c176", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x14000c17a", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000c18c" + }, + { + "address": "0x14000c17c", + "size": 7, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rip + 0x252a5]" + }, + { + "address": "0x14000c183", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 1" + }, + { + "address": "0x14000c187", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp - 0x28], xmm0" + }, + { + "address": "0x14000c18c", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp - 0x40]" + }, + { + "address": "0x14000c190", + "size": 5, + "mnemonic": "call", + "operands": "0x14000bec8" + }, + { + "address": "0x14000c195", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x18], 2" + }, + { + "address": "0x14000c199", + "size": 2, + "mnemonic": "mov", + "operands": "edi, eax" + }, + { + "address": "0x14000c19b", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000c1a8" + }, + { + "address": "0x14000c19d", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x40]" + }, + { + "address": "0x14000c1a1", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rcx + 0x3a8], 0xfffffffd" + }, + { + "address": "0x14000c1a8", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x14000c1ac", + "size": 2, + "mnemonic": "je", + "operands": "0x14000c1bd" + } + ], + "successors": [ + "0x14000c1bd", + "0x14000c1ae" + ] + }, + { + "address": "0x14000c1bd", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000c1bd", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x14000c1c1", + "size": 2, + "mnemonic": "je", + "operands": "0x14000c1d2" + } + ], + "successors": [ + "0x14000c1d2", + "0x14000c1c3" + ] + }, + { + "address": "0x14000c1ae", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000c1ae", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0x14]" + }, + { + "address": "0x14000c1b1", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x14000c1b5", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x14000c1ba", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x20], ebx" + }, + { + "address": "0x14000c1bd", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x14000c1c1", + "size": 2, + "mnemonic": "je", + "operands": "0x14000c1d2" + } + ], + "successors": [ + "0x14000c1d2", + "0x14000c1c3" + ] + }, + { + "address": "0x14000c1d2", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000c1d2", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x70]" + }, + { + "address": "0x14000c1d7", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x14000c1d9", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x78]" + }, + { + "address": "0x14000c1de", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x14000c1e2", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000c1e3", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000c1c3", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000c1c3", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0xc]" + }, + { + "address": "0x14000c1c6", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x14000c1ca", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x14000c1cf", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x24], ebx" + }, + { + "address": "0x14000c1d2", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x70]" + }, + { + "address": "0x14000c1d7", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x14000c1d9", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x78]" + }, + { + "address": "0x14000c1de", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x14000c1e2", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000c1e3", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000c2b7", + "name": "", + "blocks": [ + { + "address": "0x14000c2b7", + "size": 5, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000c2b7", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000c2b8", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14000c2bb", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x70" + }, + { + "address": "0x14000c2bf", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14000c2c2", + "size": 2, + "mnemonic": "je", + "operands": "0x14000c2f1" + } + ], + "successors": [ + "0x14000c2f1", + "0x14000c2c4" + ] + }, + { + "address": "0x14000c2f1", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000c2f1", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000c2f3", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x70" + }, + { + "address": "0x14000c2f7", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000c2f8", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000c2c4", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000c2c4", + "size": 3, + "mnemonic": "test", + "operands": "r8, r8" + }, + { + "address": "0x14000c2c7", + "size": 2, + "mnemonic": "je", + "operands": "0x14000c2f1" + } + ], + "successors": [ + "0x14000c2f1", + "0x14000c2c9" + ] + }, + { + "address": "0x14000c2c9", + "size": 15, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000c2c9", + "size": 3, + "mnemonic": "test", + "operands": "r9, r9" + }, + { + "address": "0x14000c2cc", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000c2f9" + }, + { + "address": "0x14000c2ce", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x30]" + }, + { + "address": "0x14000c2d2", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x14000c2d5", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r11 - 0x50], rax" + }, + { + "address": "0x14000c2d9", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000c2db", + "size": 4, + "mnemonic": "and", + "operands": "qword ptr [r11 - 0x58], r9" + }, + { + "address": "0x14000c2df", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14000c2e1", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rax + 0x30], 1" + }, + { + "address": "0x14000c2e5", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x2c], 0x16" + }, + { + "address": "0x14000c2ec", + "size": 5, + "mnemonic": "call", + "operands": "0x14000aefc" + }, + { + "address": "0x14000c2f1", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000c2f3", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x70" + }, + { + "address": "0x14000c2f7", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000c2f8", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000c55e", + "name": "", + "blocks": [ + { + "address": "0x14000c55e", + "size": 23, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000c55e", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000c55f", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14000c562", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x70" + }, + { + "address": "0x14000c566", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rbp - 0x40], 0" + }, + { + "address": "0x14000c56b", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x26c7e], 0" + }, + { + "address": "0x14000c572", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x30], 0" + }, + { + "address": "0x14000c576", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 0" + }, + { + "address": "0x14000c57a", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x14000c57e", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x14000c582", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000c594" + }, + { + "address": "0x14000c584", + "size": 7, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rip + 0x24e9d]" + }, + { + "address": "0x14000c58b", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 1" + }, + { + "address": "0x14000c58f", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp - 0x28], xmm0" + }, + { + "address": "0x14000c594", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp - 0x40]" + }, + { + "address": "0x14000c598", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14000c59d", + "size": 5, + "mnemonic": "call", + "operands": "0x14000c2a4" + }, + { + "address": "0x14000c5a2", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x18], 2" + }, + { + "address": "0x14000c5a6", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rax" + }, + { + "address": "0x14000c5a9", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000c5b6" + }, + { + "address": "0x14000c5ab", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x40]" + }, + { + "address": "0x14000c5af", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rcx + 0x3a8], 0xfffffffd" + }, + { + "address": "0x14000c5b6", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x14000c5ba", + "size": 2, + "mnemonic": "je", + "operands": "0x14000c5cb" + } + ], + "successors": [ + "0x14000c5cb", + "0x14000c5bc" + ] + }, + { + "address": "0x14000c5cb", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000c5cb", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x14000c5cf", + "size": 2, + "mnemonic": "je", + "operands": "0x14000c5e0" + } + ], + "successors": [ + "0x14000c5e0", + "0x14000c5d1" + ] + }, + { + "address": "0x14000c5bc", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000c5bc", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0x14]" + }, + { + "address": "0x14000c5bf", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x14000c5c3", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x14000c5c8", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x20], ebx" + }, + { + "address": "0x14000c5cb", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x14000c5cf", + "size": 2, + "mnemonic": "je", + "operands": "0x14000c5e0" + } + ], + "successors": [ + "0x14000c5e0", + "0x14000c5d1" + ] + }, + { + "address": "0x14000c5e0", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000c5e0", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x70]" + }, + { + "address": "0x14000c5e5", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdi" + }, + { + "address": "0x14000c5e8", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x10]" + }, + { + "address": "0x14000c5ec", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x18]" + }, + { + "address": "0x14000c5f0", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x14000c5f3", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000c5f4", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000c5d1", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000c5d1", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0xc]" + }, + { + "address": "0x14000c5d4", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x14000c5d8", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x14000c5dd", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x24], ebx" + }, + { + "address": "0x14000c5e0", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x70]" + }, + { + "address": "0x14000c5e5", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdi" + }, + { + "address": "0x14000c5e8", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x10]" + }, + { + "address": "0x14000c5ec", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x18]" + }, + { + "address": "0x14000c5f0", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x14000c5f3", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000c5f4", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000c720", + "name": "", + "blocks": [ + { + "address": "0x14000c720", + "size": 33, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000c720", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000c722", + "size": 1, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x14000c723", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000c724", + "size": 5, + "mnemonic": "lea", + "operands": "rbp, [rsp - 0x47]" + }, + { + "address": "0x14000c729", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0xb0" + }, + { + "address": "0x14000c730", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rbp - 0x39], 0" + }, + { + "address": "0x14000c735", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x26ab4], 0" + }, + { + "address": "0x14000c73c", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x29], 0" + }, + { + "address": "0x14000c740", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x11], 0" + }, + { + "address": "0x14000c744", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 9], 0" + }, + { + "address": "0x14000c748", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 1], 0" + }, + { + "address": "0x14000c74c", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000c75e" + }, + { + "address": "0x14000c74e", + "size": 7, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rip + 0x24cd3]" + }, + { + "address": "0x14000c755", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x11], 1" + }, + { + "address": "0x14000c759", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp - 0x21], xmm0" + }, + { + "address": "0x14000c75e", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x6f], r9" + }, + { + "address": "0x14000c762", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rbp + 0x67], r8d" + }, + { + "address": "0x14000c766", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 7], rdx" + }, + { + "address": "0x14000c76a", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x7f], rcx" + }, + { + "address": "0x14000c76e", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14000c771", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000c7a1" + }, + { + "address": "0x14000c773", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp - 0x39]" + }, + { + "address": "0x14000c777", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 9], 1" + }, + { + "address": "0x14000c77b", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x14000c780", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x14000c783", + "size": 6, + "mnemonic": "and", + "operands": "qword ptr [rsp + 0x20], 0" + }, + { + "address": "0x14000c789", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x14000c78c", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000c78e", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0xd], 0x16" + }, + { + "address": "0x14000c795", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14000c797", + "size": 5, + "mnemonic": "call", + "operands": "0x14000aefc" + }, + { + "address": "0x14000c79c", + "size": 3, + "mnemonic": "or", + "operands": "edi, 0xffffffff" + }, + { + "address": "0x14000c79f", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000c80d" + } + ], + "successors": [ + "0x14000c80d" + ] + }, + { + "address": "0x14000c80d", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000c80d", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x11], 2" + }, + { + "address": "0x14000c811", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000c81e" + }, + { + "address": "0x14000c813", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x39]" + }, + { + "address": "0x14000c817", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rcx + 0x3a8], 0xfffffffd" + }, + { + "address": "0x14000c81e", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 9], 0" + }, + { + "address": "0x14000c822", + "size": 2, + "mnemonic": "je", + "operands": "0x14000c833" + } + ], + "successors": [ + "0x14000c833", + "0x14000c824" + ] + }, + { + "address": "0x14000c833", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000c833", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 1], 0" + }, + { + "address": "0x14000c837", + "size": 2, + "mnemonic": "je", + "operands": "0x14000c848" + } + ], + "successors": [ + "0x14000c848", + "0x14000c839" + ] + }, + { + "address": "0x14000c824", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000c824", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0xd]" + }, + { + "address": "0x14000c827", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x39]" + }, + { + "address": "0x14000c82b", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x14000c830", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x20], ebx" + }, + { + "address": "0x14000c833", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 1], 0" + }, + { + "address": "0x14000c837", + "size": 2, + "mnemonic": "je", + "operands": "0x14000c848" + } + ], + "successors": [ + "0x14000c848", + "0x14000c839" + ] + }, + { + "address": "0x14000c848", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000c848", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x14000c84a", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0xb0" + }, + { + "address": "0x14000c851", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000c852", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000c853", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000c854", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000c839", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000c839", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 5]" + }, + { + "address": "0x14000c83c", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x39]" + }, + { + "address": "0x14000c840", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x14000c845", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x24], ebx" + }, + { + "address": "0x14000c848", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x14000c84a", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0xb0" + }, + { + "address": "0x14000c851", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000c852", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000c853", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000c854", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000cb12", + "name": "", + "blocks": [ + { + "address": "0x14000cb12", + "size": 19, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000cb12", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000cb13", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000cb14", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x14000cb16", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000cb18", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14000cb1a", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14000cb1d", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x14000cb21", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 8]" + }, + { + "address": "0x14000cb25", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000cb27", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x14000cb2a", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rax]" + }, + { + "address": "0x14000cb2d", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x14000cb30", + "size": 3, + "mnemonic": "mov", + "operands": "r14d, dword ptr [rax]" + }, + { + "address": "0x14000cb33", + "size": 3, + "mnemonic": "test", + "operands": "rsi, rsi" + }, + { + "address": "0x14000cb36", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000cb48" + }, + { + "address": "0x14000cb38", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, r14d" + }, + { + "address": "0x14000cb3b", + "size": 5, + "mnemonic": "call", + "operands": "0x14000f858" + }, + { + "address": "0x14000cb40", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rax" + }, + { + "address": "0x14000cb43", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000cbf5" + } + ], + "successors": [ + "0x14000cbf5" + ] + }, + { + "address": "0x14000cbf5", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000cbf5", + "size": 3, + "mnemonic": "test", + "operands": "r14, r14" + }, + { + "address": "0x14000cbf8", + "size": 2, + "mnemonic": "je", + "operands": "0x14000cb94" + } + ], + "successors": [ + "0x14000cb94", + "0x14000cbfa" + ] + }, + { + "address": "0x14000cb94", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000cb94", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000cb96", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x40]" + }, + { + "address": "0x14000cb9b", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x40]" + }, + { + "address": "0x14000cb9f", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x48]" + }, + { + "address": "0x14000cba3", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x14000cba6", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000cba8", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000cbaa", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14000cbac", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000cbad", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000cbae", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000cbfa", + "size": 17, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000cbfa", + "size": 5, + "mnemonic": "call", + "operands": "0x1400118c4" + }, + { + "address": "0x14000cbff", + "size": 3, + "mnemonic": "mov", + "operands": "r13, rax" + }, + { + "address": "0x14000cc02", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r14" + }, + { + "address": "0x14000cc05", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x14000cc08", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000cc0a", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax + 0x90]" + }, + { + "address": "0x14000cc11", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x10], rcx" + }, + { + "address": "0x14000cc15", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax + 0x88]" + }, + { + "address": "0x14000cc1c", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp - 0x10]" + }, + { + "address": "0x14000cc20", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rbp + 0x38], 0" + }, + { + "address": "0x14000cc25", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 8], rcx" + }, + { + "address": "0x14000cc29", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x38]" + }, + { + "address": "0x14000cc2d", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x14000cc32", + "size": 6, + "mnemonic": "and", + "operands": "qword ptr [rsp + 0x20], 0" + }, + { + "address": "0x14000cc38", + "size": 5, + "mnemonic": "call", + "operands": "0x140015a74" + }, + { + "address": "0x14000cc3d", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000cc3f", + "size": 2, + "mnemonic": "je", + "operands": "0x14000cc58" + } + ], + "successors": [ + "0x14000cc58", + "0x14000cc41" + ] + }, + { + "address": "0x14000cc58", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000cc58", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x38]" + }, + { + "address": "0x14000cc5c", + "size": 4, + "mnemonic": "add", + "operands": "rcx, 4" + }, + { + "address": "0x14000cc60", + "size": 5, + "mnemonic": "call", + "operands": "0x140015200" + }, + { + "address": "0x14000cc65", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rax" + }, + { + "address": "0x14000cc68", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000cc6b", + "size": 6, + "mnemonic": "je", + "operands": "0x14000cb94" + } + ], + "successors": [ + "0x14000cb94", + "0x14000cc71" + ] + }, + { + "address": "0x14000cc41", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000cc41", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 0x16" + }, + { + "address": "0x14000cc44", + "size": 6, + "mnemonic": "je", + "operands": "0x14000cd91" + } + ], + "successors": [ + "0x14000cd91", + "0x14000cc4a" + ] + }, + { + "address": "0x14000cc71", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000cc71", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [rbp + 0x38]" + }, + { + "address": "0x14000cc75", + "size": 4, + "mnemonic": "lea", + "operands": "r15, [rax + 4]" + }, + { + "address": "0x14000cc79", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp - 0x10]" + }, + { + "address": "0x14000cc7d", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r14" + }, + { + "address": "0x14000cc80", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x14000cc85", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r15" + }, + { + "address": "0x14000cc88", + "size": 6, + "mnemonic": "or", + "operands": "qword ptr [rsp + 0x20], 0xffffffffffffffff" + }, + { + "address": "0x14000cc8e", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14000cc90", + "size": 5, + "mnemonic": "call", + "operands": "0x140015a74" + }, + { + "address": "0x14000cc95", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000cc97", + "size": 2, + "mnemonic": "je", + "operands": "0x14000ccb3" + } + ], + "successors": [ + "0x14000ccb3", + "0x14000cc99" + ] + }, + { + "address": "0x14000cd91", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000cd91", + "size": 6, + "mnemonic": "and", + "operands": "qword ptr [rsp + 0x20], 0" + }, + { + "address": "0x14000cd97", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x14000cd9a", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x14000cd9d", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000cd9f", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14000cda1", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afd4" + }, + { + "address": "0x14000cda6", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000cc4a", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000cc4a", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 0x22" + }, + { + "address": "0x14000cc4d", + "size": 6, + "mnemonic": "je", + "operands": "0x14000cd91" + } + ], + "successors": [ + "0x14000cd91", + "0x14000cc53" + ] + }, + { + "address": "0x14000ccb3", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ccb3", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdi]" + }, + { + "address": "0x14000ccb6", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rbp - 0x10]" + }, + { + "address": "0x14000ccba", + "size": 3, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax]" + }, + { + "address": "0x14000ccbd", + "size": 4, + "mnemonic": "shl", + "operands": "rcx, 5" + }, + { + "address": "0x14000ccc1", + "size": 5, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rcx + rbx + 0x30]" + }, + { + "address": "0x14000ccc6", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14000ccc9", + "size": 2, + "mnemonic": "je", + "operands": "0x14000ccfb" + } + ], + "successors": [ + "0x14000ccfb", + "0x14000cccb" + ] + }, + { + "address": "0x14000cc99", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000cc99", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 0x16" + }, + { + "address": "0x14000cc9c", + "size": 6, + "mnemonic": "je", + "operands": "0x14000cd91" + } + ], + "successors": [ + "0x14000cd91", + "0x14000cca2" + ] + }, + { + "address": "0x14000cc53", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000cc53", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000cb94" + } + ], + "successors": [ + "0x14000cb94" + ] + }, + { + "address": "0x14000ccfb", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ccfb", + "size": 7, + "mnemonic": "mov", + "operands": "eax, dword ptr [r13 + 0x3a8]" + }, + { + "address": "0x14000cd02", + "size": 6, + "mnemonic": "test", + "operands": "dword ptr [rip + 0x24888], eax" + }, + { + "address": "0x14000cd08", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000cd4e" + }, + { + "address": "0x14000cd0a", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdi]" + }, + { + "address": "0x14000cd0d", + "size": 3, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax]" + }, + { + "address": "0x14000cd10", + "size": 4, + "mnemonic": "shl", + "operands": "rcx, 5" + }, + { + "address": "0x14000cd14", + "size": 5, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rcx + rbx + 0x30]" + }, + { + "address": "0x14000cd19", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14000cd1c", + "size": 2, + "mnemonic": "je", + "operands": "0x14000cd4e" + } + ], + "successors": [ + "0x14000cd4e", + "0x14000cd1e" + ] + }, + { + "address": "0x14000cccb", + "size": 22, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000cccb", + "size": 3, + "mnemonic": "or", + "operands": "eax, 0xffffffff" + }, + { + "address": "0x14000ccce", + "size": 4, + "mnemonic": "lock xadd", + "operands": "dword ptr [rdx], eax" + }, + { + "address": "0x14000ccd2", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x14000ccd5", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000ccfb" + }, + { + "address": "0x14000ccd7", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdi]" + }, + { + "address": "0x14000ccda", + "size": 3, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax]" + }, + { + "address": "0x14000ccdd", + "size": 4, + "mnemonic": "shl", + "operands": "rcx, 5" + }, + { + "address": "0x14000cce1", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + rbx + 0x30]" + }, + { + "address": "0x14000cce6", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14000cceb", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdi]" + }, + { + "address": "0x14000ccee", + "size": 3, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax]" + }, + { + "address": "0x14000ccf1", + "size": 4, + "mnemonic": "shl", + "operands": "rcx, 5" + }, + { + "address": "0x14000ccf5", + "size": 6, + "mnemonic": "and", + "operands": "qword ptr [rcx + rbx + 0x30], 0" + }, + { + "address": "0x14000ccfb", + "size": 7, + "mnemonic": "mov", + "operands": "eax, dword ptr [r13 + 0x3a8]" + }, + { + "address": "0x14000cd02", + "size": 6, + "mnemonic": "test", + "operands": "dword ptr [rip + 0x24888], eax" + }, + { + "address": "0x14000cd08", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000cd4e" + }, + { + "address": "0x14000cd0a", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdi]" + }, + { + "address": "0x14000cd0d", + "size": 3, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax]" + }, + { + "address": "0x14000cd10", + "size": 4, + "mnemonic": "shl", + "operands": "rcx, 5" + }, + { + "address": "0x14000cd14", + "size": 5, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rcx + rbx + 0x30]" + }, + { + "address": "0x14000cd19", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14000cd1c", + "size": 2, + "mnemonic": "je", + "operands": "0x14000cd4e" + } + ], + "successors": [ + "0x14000cd4e", + "0x14000cd1e" + ] + }, + { + "address": "0x14000cca2", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000cca2", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 0x22" + }, + { + "address": "0x14000cca5", + "size": 6, + "mnemonic": "je", + "operands": "0x14000cd91" + } + ], + "successors": [ + "0x14000cd91", + "0x14000ccab" + ] + }, + { + "address": "0x14000cd4e", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000cd4e", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbx + 0x10]" + }, + { + "address": "0x14000cd51", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r15" + }, + { + "address": "0x14000cd54", + "size": 2, + "mnemonic": "mov", + "operands": "dword ptr [rsi], ecx" + }, + { + "address": "0x14000cd56", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdi]" + }, + { + "address": "0x14000cd59", + "size": 3, + "mnemonic": "movsxd", + "operands": "rdx, dword ptr [rcx]" + }, + { + "address": "0x14000cd5c", + "size": 4, + "mnemonic": "shl", + "operands": "rdx, 5" + }, + { + "address": "0x14000cd60", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rdx + rbx + 0x30], rsi" + }, + { + "address": "0x14000cd65", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdi]" + }, + { + "address": "0x14000cd68", + "size": 3, + "mnemonic": "movsxd", + "operands": "rdx, dword ptr [rcx]" + }, + { + "address": "0x14000cd6b", + "size": 3, + "mnemonic": "inc", + "operands": "rdx" + }, + { + "address": "0x14000cd6e", + "size": 4, + "mnemonic": "shl", + "operands": "rdx, 5" + }, + { + "address": "0x14000cd72", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rdx + rbx], r15" + }, + { + "address": "0x14000cd76", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000cb96" + } + ], + "successors": [ + "0x14000cb96" + ] + }, + { + "address": "0x14000cd1e", + "size": 26, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000cd1e", + "size": 3, + "mnemonic": "or", + "operands": "eax, 0xffffffff" + }, + { + "address": "0x14000cd21", + "size": 4, + "mnemonic": "lock xadd", + "operands": "dword ptr [rdx], eax" + }, + { + "address": "0x14000cd25", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x14000cd28", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000cd4e" + }, + { + "address": "0x14000cd2a", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdi]" + }, + { + "address": "0x14000cd2d", + "size": 3, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax]" + }, + { + "address": "0x14000cd30", + "size": 4, + "mnemonic": "shl", + "operands": "rcx, 5" + }, + { + "address": "0x14000cd34", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + rbx + 0x30]" + }, + { + "address": "0x14000cd39", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14000cd3e", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdi]" + }, + { + "address": "0x14000cd41", + "size": 3, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax]" + }, + { + "address": "0x14000cd44", + "size": 4, + "mnemonic": "shl", + "operands": "rcx, 5" + }, + { + "address": "0x14000cd48", + "size": 6, + "mnemonic": "and", + "operands": "qword ptr [rcx + rbx + 0x30], 0" + }, + { + "address": "0x14000cd4e", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbx + 0x10]" + }, + { + "address": "0x14000cd51", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r15" + }, + { + "address": "0x14000cd54", + "size": 2, + "mnemonic": "mov", + "operands": "dword ptr [rsi], ecx" + }, + { + "address": "0x14000cd56", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdi]" + }, + { + "address": "0x14000cd59", + "size": 3, + "mnemonic": "movsxd", + "operands": "rdx, dword ptr [rcx]" + }, + { + "address": "0x14000cd5c", + "size": 4, + "mnemonic": "shl", + "operands": "rdx, 5" + }, + { + "address": "0x14000cd60", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rdx + rbx + 0x30], rsi" + }, + { + "address": "0x14000cd65", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdi]" + }, + { + "address": "0x14000cd68", + "size": 3, + "mnemonic": "movsxd", + "operands": "rdx, dword ptr [rcx]" + }, + { + "address": "0x14000cd6b", + "size": 3, + "mnemonic": "inc", + "operands": "rdx" + }, + { + "address": "0x14000cd6e", + "size": 4, + "mnemonic": "shl", + "operands": "rdx, 5" + }, + { + "address": "0x14000cd72", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rdx + rbx], r15" + }, + { + "address": "0x14000cd76", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000cb96" + } + ], + "successors": [ + "0x14000cb96" + ] + }, + { + "address": "0x14000ccab", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ccab", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x14000ccae", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000cb8f" + } + ], + "successors": [ + "0x14000cb8f" + ] + }, + { + "address": "0x14000cb96", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000cb96", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x40]" + }, + { + "address": "0x14000cb9b", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x40]" + }, + { + "address": "0x14000cb9f", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x48]" + }, + { + "address": "0x14000cba3", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x14000cba6", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000cba8", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000cbaa", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14000cbac", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000cbad", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000cbae", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000cb8f", + "size": 12, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000cb8f", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14000cb94", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000cb96", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x40]" + }, + { + "address": "0x14000cb9b", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x40]" + }, + { + "address": "0x14000cb9f", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x48]" + }, + { + "address": "0x14000cba3", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x14000cba6", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000cba8", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000cbaa", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14000cbac", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000cbad", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000cbae", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000cdb1", + "name": "", + "blocks": [ + { + "address": "0x14000cdb1", + "size": 19, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000cdb1", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000cdb2", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14000cdb5", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x14000cdb9", + "size": 5, + "mnemonic": "call", + "operands": "0x140012358" + }, + { + "address": "0x14000cdbe", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x10]" + }, + { + "address": "0x14000cdc2", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x18], rax" + }, + { + "address": "0x14000cdc6", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp + 0x28]" + }, + { + "address": "0x14000cdca", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x18]" + }, + { + "address": "0x14000cdce", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x10], rax" + }, + { + "address": "0x14000cdd2", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbp - 0x18]" + }, + { + "address": "0x14000cdd6", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 4" + }, + { + "address": "0x14000cddb", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x20]" + }, + { + "address": "0x14000cddf", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x20]" + }, + { + "address": "0x14000cde3", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp + 0x28], eax" + }, + { + "address": "0x14000cde6", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x20], eax" + }, + { + "address": "0x14000cde9", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cac8" + }, + { + "address": "0x14000cdee", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x40" + }, + { + "address": "0x14000cdf2", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000cdf3", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000e389", + "name": "", + "blocks": [ + { + "address": "0x14000e389", + "size": 11, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000e389", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000e38a", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x14000e38b", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000e38c", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000e38e", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14000e390", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14000e393", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000e397", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x14000e399", + "size": 3, + "mnemonic": "mov", + "operands": "r14d, ecx" + }, + { + "address": "0x14000e39c", + "size": 2, + "mnemonic": "test", + "operands": "ecx, ecx" + }, + { + "address": "0x14000e39e", + "size": 6, + "mnemonic": "je", + "operands": "0x14000e4ee" + } + ], + "successors": [ + "0x14000e4ee", + "0x14000e3a4" + ] + }, + { + "address": "0x14000e4ee", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000e4ee", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14000e4f3", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x14000e4f5", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000e4f9", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000e4fb", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000e4fd", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000e4fe", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14000e4ff", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000e500", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000e3a4", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000e3a4", + "size": 3, + "mnemonic": "lea", + "operands": "eax, [rcx - 1]" + }, + { + "address": "0x14000e3a7", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x14000e3aa", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14000e3c2" + }, + { + "address": "0x14000e3ac", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x14000e3b1", + "size": 5, + "mnemonic": "mov", + "operands": "edi, 0x16" + }, + { + "address": "0x14000e3b6", + "size": 2, + "mnemonic": "mov", + "operands": "dword ptr [rax], edi" + }, + { + "address": "0x14000e3b8", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afb4" + }, + { + "address": "0x14000e3bd", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000e4ee" + } + ], + "successors": [ + "0x14000e4ee" + ] + } + ] + }, + { + "address": "0x14000ea35", + "name": "", + "blocks": [ + { + "address": "0x14000ea35", + "size": 12, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ea35", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000ea36", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14000ea39", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x50" + }, + { + "address": "0x14000ea3d", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x20], 0xfffffffffffffffe" + }, + { + "address": "0x14000ea45", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x60], rbx" + }, + { + "address": "0x14000ea4a", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, ecx" + }, + { + "address": "0x14000ea4c", + "size": 3, + "mnemonic": "test", + "operands": "r8d, r8d" + }, + { + "address": "0x14000ea4f", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000ea9b" + }, + { + "address": "0x14000ea51", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14000ea53", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x11677]" + }, + { + "address": "0x14000ea59", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000ea5c", + "size": 2, + "mnemonic": "je", + "operands": "0x14000ea9b" + } + ], + "successors": [ + "0x14000ea9b", + "0x14000ea5e" + ] + } + ] + }, + { + "address": "0x14000f36c", + "name": "", + "blocks": [ + { + "address": "0x14000f36c", + "size": 40, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000f36c", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000f36e", + "size": 1, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x14000f36f", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x14000f370", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000f371", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x14000f373", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x14000f375", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000f377", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14000f379", + "size": 8, + "mnemonic": "lea", + "operands": "rbp, [rsp - 0x168]" + }, + { + "address": "0x14000f381", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x268" + }, + { + "address": "0x14000f388", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x21cb1]" + }, + { + "address": "0x14000f38f", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x14000f392", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x150], rax" + }, + { + "address": "0x14000f399", + "size": 7, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rbp + 0x1d0]" + }, + { + "address": "0x14000f3a0", + "size": 3, + "mnemonic": "xor", + "operands": "r15d, r15d" + }, + { + "address": "0x14000f3a3", + "size": 7, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rbp + 0x1d8]" + }, + { + "address": "0x14000f3aa", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r8" + }, + { + "address": "0x14000f3ad", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x70], rax" + }, + { + "address": "0x14000f3b2", + "size": 3, + "mnemonic": "mov", + "operands": "r13, r9" + }, + { + "address": "0x14000f3b5", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x78], rdx" + }, + { + "address": "0x14000f3ba", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rdx" + }, + { + "address": "0x14000f3bd", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x60], rdi" + }, + { + "address": "0x14000f3c2", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14000f3c5", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x68], rsi" + }, + { + "address": "0x14000f3ca", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14000f3cd", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000f3f4" + }, + { + "address": "0x14000f3cf", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000f3d1", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x150]" + }, + { + "address": "0x14000f3d8", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x14000f3db", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x14000f3e0", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0x268" + }, + { + "address": "0x14000f3e7", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000f3e9", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000f3eb", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14000f3ed", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14000f3ef", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000f3f0", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14000f3f1", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000f3f2", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000f3f3", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000f801", + "name": "", + "blocks": [ + { + "address": "0x14000f801", + "size": 19, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000f801", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000f802", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x14000f803", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000f804", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x48" + }, + { + "address": "0x14000f808", + "size": 4, + "mnemonic": "lea", + "operands": "rdi, [rax + 0x20]" + }, + { + "address": "0x14000f80c", + "size": 2, + "mnemonic": "xor", + "operands": "ebx, ebx" + }, + { + "address": "0x14000f80e", + "size": 4, + "mnemonic": "add", + "operands": "rdi, -8" + }, + { + "address": "0x14000f812", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rdx" + }, + { + "address": "0x14000f815", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rcx" + }, + { + "address": "0x14000f818", + "size": 4, + "mnemonic": "lea", + "operands": "rdi, [rdi + 8]" + }, + { + "address": "0x14000f81c", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x14000f81f", + "size": 3, + "mnemonic": "mov", + "operands": "r8, qword ptr [rdi]" + }, + { + "address": "0x14000f822", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbp" + }, + { + "address": "0x14000f825", + "size": 5, + "mnemonic": "call", + "operands": "0x140017480" + }, + { + "address": "0x14000f82a", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000f82c", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000f842" + }, + { + "address": "0x14000f82e", + "size": 2, + "mnemonic": "inc", + "operands": "ebx" + }, + { + "address": "0x14000f830", + "size": 7, + "mnemonic": "cmp", + "operands": "ebx, dword ptr [rsp + 0x80]" + }, + { + "address": "0x14000f837", + "size": 2, + "mnemonic": "jl", + "operands": "0x14000f818" + } + ], + "successors": [ + "0x14000f818", + "0x14000f839" + ] + }, + { + "address": "0x14000f818", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000f818", + "size": 4, + "mnemonic": "lea", + "operands": "rdi, [rdi + 8]" + }, + { + "address": "0x14000f81c", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x14000f81f", + "size": 3, + "mnemonic": "mov", + "operands": "r8, qword ptr [rdi]" + }, + { + "address": "0x14000f822", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbp" + }, + { + "address": "0x14000f825", + "size": 5, + "mnemonic": "call", + "operands": "0x140017480" + }, + { + "address": "0x14000f82a", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000f82c", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000f842" + }, + { + "address": "0x14000f82e", + "size": 2, + "mnemonic": "inc", + "operands": "ebx" + }, + { + "address": "0x14000f830", + "size": 7, + "mnemonic": "cmp", + "operands": "ebx, dword ptr [rsp + 0x80]" + }, + { + "address": "0x14000f837", + "size": 2, + "mnemonic": "jl", + "operands": "0x14000f818" + } + ], + "successors": [ + "0x14000f818", + "0x14000f839" + ] + }, + { + "address": "0x14000f839", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000f839", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x48" + }, + { + "address": "0x14000f83d", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000f83e", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14000f83f", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000f840", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000f841", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000f861", + "name": "", + "blocks": [ + { + "address": "0x14000f861", + "size": 12, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000f861", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000f862", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14000f865", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x14000f869", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rbp - 0x40], 0" + }, + { + "address": "0x14000f86e", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rbp - 0x38], 0" + }, + { + "address": "0x14000f873", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, 5" + }, + { + "address": "0x14000f876", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14000f88c" + }, + { + "address": "0x14000f878", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x14000f87d", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0x16" + }, + { + "address": "0x14000f883", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afb4" + }, + { + "address": "0x14000f888", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000f88a", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000f8f3" + } + ], + "successors": [ + "0x14000f8f3" + ] + }, + { + "address": "0x14000f8f3", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000f8f3", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x14000f8f7", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000f8f8", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000faed", + "name": "", + "blocks": [ + { + "address": "0x14000faed", + "size": 16, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000faed", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000faee", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x14000faef", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000faf0", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x14000faf2", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x14000faf4", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000faf6", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14000faf8", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x210" + }, + { + "address": "0x14000faff", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x2153a]" + }, + { + "address": "0x14000fb06", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x14000fb09", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x200], rax" + }, + { + "address": "0x14000fb11", + "size": 3, + "mnemonic": "xor", + "operands": "r13d, r13d" + }, + { + "address": "0x14000fb14", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r8" + }, + { + "address": "0x14000fb17", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x14000fb1a", + "size": 2, + "mnemonic": "test", + "operands": "edx, edx" + }, + { + "address": "0x14000fb1c", + "size": 2, + "mnemonic": "je", + "operands": "0x14000fb3e" + } + ], + "successors": [ + "0x14000fb3e", + "0x14000fb1e" + ] + }, + { + "address": "0x14000fb3e", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fb3e", + "size": 5, + "mnemonic": "mov", + "operands": "ebp, 1" + }, + { + "address": "0x14000fb43", + "size": 3, + "mnemonic": "mov", + "operands": "esi, r13d" + }, + { + "address": "0x14000fb46", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x14000fb49", + "size": 6, + "mnemonic": "je", + "operands": "0x14000fc8b" + } + ], + "successors": [ + "0x14000fc8b", + "0x14000fb4f" + ] + }, + { + "address": "0x14000fb1e", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fb1e", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x14000fb21", + "size": 2, + "mnemonic": "je", + "operands": "0x14000fb2d" + } + ], + "successors": [ + "0x14000fb2d", + "0x14000fb23" + ] + }, + { + "address": "0x14000fc8b", + "size": 14, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000fc8b", + "size": 5, + "mnemonic": "call", + "operands": "0x14000f8fc" + }, + { + "address": "0x14000fc90", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x200]" + }, + { + "address": "0x14000fc98", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x14000fc9b", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x14000fca0", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x268]" + }, + { + "address": "0x14000fca8", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0x210" + }, + { + "address": "0x14000fcaf", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000fcb1", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000fcb3", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14000fcb5", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14000fcb7", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000fcb8", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14000fcb9", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000fcba", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000fb4f", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fb4f", + "size": 5, + "mnemonic": "cmp", + "operands": "word ptr [r8], 0x4c" + }, + { + "address": "0x14000fb54", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000fcbf" + }, + { + "address": "0x14000fb5a", + "size": 6, + "mnemonic": "cmp", + "operands": "word ptr [r8 + 2], 0x43" + }, + { + "address": "0x14000fb60", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000fcbf" + }, + { + "address": "0x14000fb66", + "size": 6, + "mnemonic": "cmp", + "operands": "word ptr [r8 + 4], 0x5f" + }, + { + "address": "0x14000fb6c", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000fcbf" + }, + { + "address": "0x14000fb72", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x15f47]" + }, + { + "address": "0x14000fb79", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x14000fb7c", + "size": 5, + "mnemonic": "call", + "operands": "0x14001a560" + }, + { + "address": "0x14000fb81", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rax" + }, + { + "address": "0x14000fb84", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000fb87", + "size": 6, + "mnemonic": "je", + "operands": "0x14000fcbb" + } + ], + "successors": [ + "0x14000fcbb", + "0x14000fb8d" + ] + }, + { + "address": "0x14000fb2d", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fb2d", + "size": 3, + "mnemonic": "movsxd", + "operands": "rax, edx" + }, + { + "address": "0x14000fb30", + "size": 4, + "mnemonic": "shl", + "operands": "rax, 5" + }, + { + "address": "0x14000fb34", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax + rcx + 0x28]" + }, + { + "address": "0x14000fb39", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000fc90" + } + ], + "successors": [ + "0x14000fc90" + ] + }, + { + "address": "0x14000fb23", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fb23", + "size": 5, + "mnemonic": "call", + "operands": "0x14000fd80" + }, + { + "address": "0x14000fb28", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000fc90" + } + ], + "successors": [ + "0x14000fc90" + ] + }, + { + "address": "0x14000fcbb", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fcbb", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000fcbd", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000fc90" + } + ], + "successors": [ + "0x14000fc90" + ] + }, + { + "address": "0x14000fb8d", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fb8d", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rax" + }, + { + "address": "0x14000fb90", + "size": 3, + "mnemonic": "sub", + "operands": "rbp, rbx" + }, + { + "address": "0x14000fb93", + "size": 3, + "mnemonic": "sar", + "operands": "rbp, 1" + }, + { + "address": "0x14000fb96", + "size": 6, + "mnemonic": "je", + "operands": "0x14000fcbb" + } + ], + "successors": [ + "0x14000fcbb", + "0x14000fb9c" + ] + }, + { + "address": "0x14000fc90", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000fc90", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x200]" + }, + { + "address": "0x14000fc98", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x14000fc9b", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x14000fca0", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x268]" + }, + { + "address": "0x14000fca8", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0x210" + }, + { + "address": "0x14000fcaf", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000fcb1", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000fcb3", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14000fcb5", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14000fcb7", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000fcb8", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14000fcb9", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000fcba", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000fb9c", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fb9c", + "size": 4, + "mnemonic": "cmp", + "operands": "word ptr [rax], 0x3b" + }, + { + "address": "0x14000fba0", + "size": 6, + "mnemonic": "je", + "operands": "0x14000fcbb" + } + ], + "successors": [ + "0x14000fcbb", + "0x14000fba6" + ] + }, + { + "address": "0x14000fba6", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fba6", + "size": 6, + "mnemonic": "mov", + "operands": "r12d, 1" + }, + { + "address": "0x14000fbac", + "size": 7, + "mnemonic": "lea", + "operands": "r15, [rip + 0x15e15]" + }, + { + "address": "0x14000fbb3", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r15]" + }, + { + "address": "0x14000fbb6", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rbp" + }, + { + "address": "0x14000fbb9", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x14000fbbc", + "size": 5, + "mnemonic": "call", + "operands": "0x140011460" + }, + { + "address": "0x14000fbc1", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000fbc3", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000fbdb" + }, + { + "address": "0x14000fbc5", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r15]" + }, + { + "address": "0x14000fbc8", + "size": 4, + "mnemonic": "or", + "operands": "rax, 0xffffffffffffffff" + }, + { + "address": "0x14000fbcc", + "size": 3, + "mnemonic": "inc", + "operands": "rax" + }, + { + "address": "0x14000fbcf", + "size": 5, + "mnemonic": "cmp", + "operands": "word ptr [rcx + rax*2], r13w" + }, + { + "address": "0x14000fbd4", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000fbcc" + }, + { + "address": "0x14000fbd6", + "size": 3, + "mnemonic": "cmp", + "operands": "rbp, rax" + }, + { + "address": "0x14000fbd9", + "size": 2, + "mnemonic": "je", + "operands": "0x14000fbee" + } + ], + "successors": [ + "0x14000fbee", + "0x14000fbdb" + ] + }, + { + "address": "0x14000fbee", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fbee", + "size": 4, + "mnemonic": "add", + "operands": "r14, 2" + }, + { + "address": "0x14000fbf2", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x15ecf]" + }, + { + "address": "0x14000fbf9", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r14" + }, + { + "address": "0x14000fbfc", + "size": 5, + "mnemonic": "call", + "operands": "0x14001a500" + }, + { + "address": "0x14000fc01", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x14000fc04", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000fc07", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000fc14" + }, + { + "address": "0x14000fc09", + "size": 5, + "mnemonic": "cmp", + "operands": "word ptr [r14], 0x3b" + }, + { + "address": "0x14000fc0e", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000fcbb" + }, + { + "address": "0x14000fc14", + "size": 4, + "mnemonic": "cmp", + "operands": "r12d, 5" + }, + { + "address": "0x14000fc18", + "size": 2, + "mnemonic": "jg", + "operands": "0x14000fc64" + } + ], + "successors": [ + "0x14000fc64", + "0x14000fc1a" + ] + }, + { + "address": "0x14000fbdb", + "size": 16, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fbdb", + "size": 3, + "mnemonic": "inc", + "operands": "r12d" + }, + { + "address": "0x14000fbde", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x15e43]" + }, + { + "address": "0x14000fbe5", + "size": 4, + "mnemonic": "add", + "operands": "r15, 0x18" + }, + { + "address": "0x14000fbe9", + "size": 3, + "mnemonic": "cmp", + "operands": "r15, rax" + }, + { + "address": "0x14000fbec", + "size": 2, + "mnemonic": "jle", + "operands": "0x14000fbb3" + }, + { + "address": "0x14000fbee", + "size": 4, + "mnemonic": "add", + "operands": "r14, 2" + }, + { + "address": "0x14000fbf2", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x15ecf]" + }, + { + "address": "0x14000fbf9", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r14" + }, + { + "address": "0x14000fbfc", + "size": 5, + "mnemonic": "call", + "operands": "0x14001a500" + }, + { + "address": "0x14000fc01", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x14000fc04", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000fc07", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000fc14" + }, + { + "address": "0x14000fc09", + "size": 5, + "mnemonic": "cmp", + "operands": "word ptr [r14], 0x3b" + }, + { + "address": "0x14000fc0e", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000fcbb" + }, + { + "address": "0x14000fc14", + "size": 4, + "mnemonic": "cmp", + "operands": "r12d, 5" + }, + { + "address": "0x14000fc18", + "size": 2, + "mnemonic": "jg", + "operands": "0x14000fc64" + } + ], + "successors": [ + "0x14000fc64", + "0x14000fc1a" + ] + }, + { + "address": "0x14000fc64", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fc64", + "size": 4, + "mnemonic": "lea", + "operands": "rbx, [r14 + rbx*2]" + }, + { + "address": "0x14000fc68", + "size": 3, + "mnemonic": "movzx", + "operands": "eax, word ptr [rbx]" + }, + { + "address": "0x14000fc6b", + "size": 3, + "mnemonic": "test", + "operands": "ax, ax" + }, + { + "address": "0x14000fc6e", + "size": 2, + "mnemonic": "je", + "operands": "0x14000fc80" + } + ], + "successors": [ + "0x14000fc80", + "0x14000fc70" + ] + }, + { + "address": "0x14000fc1a", + "size": 17, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fc1a", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rbx" + }, + { + "address": "0x14000fc1d", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x40]" + }, + { + "address": "0x14000fc22", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x14000fc25", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0x83" + }, + { + "address": "0x14000fc2a", + "size": 5, + "mnemonic": "call", + "operands": "0x140017510" + }, + { + "address": "0x14000fc2f", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000fc31", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000fd68" + }, + { + "address": "0x14000fc37", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbx + rbx]" + }, + { + "address": "0x14000fc3b", + "size": 6, + "mnemonic": "cmp", + "operands": "rax, 0x106" + }, + { + "address": "0x14000fc41", + "size": 6, + "mnemonic": "jae", + "operands": "0x14000fd62" + }, + { + "address": "0x14000fc47", + "size": 5, + "mnemonic": "lea", + "operands": "r8, [rsp + 0x40]" + }, + { + "address": "0x14000fc4c", + "size": 6, + "mnemonic": "mov", + "operands": "word ptr [rsp + rax + 0x40], r13w" + }, + { + "address": "0x14000fc52", + "size": 3, + "mnemonic": "mov", + "operands": "edx, r12d" + }, + { + "address": "0x14000fc55", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x14000fc58", + "size": 5, + "mnemonic": "call", + "operands": "0x14000fd80" + }, + { + "address": "0x14000fc5d", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000fc60", + "size": 2, + "mnemonic": "je", + "operands": "0x14000fc64" + } + ], + "successors": [ + "0x14000fc64", + "0x14000fc62" + ] + }, + { + "address": "0x14000fc80", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fc80", + "size": 2, + "mnemonic": "test", + "operands": "esi, esi" + }, + { + "address": "0x14000fc82", + "size": 6, + "mnemonic": "je", + "operands": "0x14000fd5a" + } + ], + "successors": [ + "0x14000fd5a", + "0x14000fc88" + ] + }, + { + "address": "0x14000fc70", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fc70", + "size": 4, + "mnemonic": "add", + "operands": "rbx, 2" + }, + { + "address": "0x14000fc74", + "size": 3, + "mnemonic": "movzx", + "operands": "eax, word ptr [rbx]" + }, + { + "address": "0x14000fc77", + "size": 3, + "mnemonic": "test", + "operands": "ax, ax" + }, + { + "address": "0x14000fc7a", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000fb72" + }, + { + "address": "0x14000fc80", + "size": 2, + "mnemonic": "test", + "operands": "esi, esi" + }, + { + "address": "0x14000fc82", + "size": 6, + "mnemonic": "je", + "operands": "0x14000fd5a" + } + ], + "successors": [ + "0x14000fd5a", + "0x14000fc88" + ] + }, + { + "address": "0x14000fc62", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fc62", + "size": 2, + "mnemonic": "inc", + "operands": "esi" + }, + { + "address": "0x14000fc64", + "size": 4, + "mnemonic": "lea", + "operands": "rbx, [r14 + rbx*2]" + }, + { + "address": "0x14000fc68", + "size": 3, + "mnemonic": "movzx", + "operands": "eax, word ptr [rbx]" + }, + { + "address": "0x14000fc6b", + "size": 3, + "mnemonic": "test", + "operands": "ax, ax" + }, + { + "address": "0x14000fc6e", + "size": 2, + "mnemonic": "je", + "operands": "0x14000fc80" + } + ], + "successors": [ + "0x14000fc80", + "0x14000fc70" + ] + }, + { + "address": "0x14000fd5a", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fd5a", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r13" + }, + { + "address": "0x14000fd5d", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000fc90" + } + ], + "successors": [ + "0x14000fc90" + ] + }, + { + "address": "0x14000fc88", + "size": 15, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000fc88", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x14000fc8b", + "size": 5, + "mnemonic": "call", + "operands": "0x14000f8fc" + }, + { + "address": "0x14000fc90", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x200]" + }, + { + "address": "0x14000fc98", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x14000fc9b", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x14000fca0", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x268]" + }, + { + "address": "0x14000fca8", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0x210" + }, + { + "address": "0x14000fcaf", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000fcb1", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000fcb3", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14000fcb5", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14000fcb7", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000fcb8", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14000fcb9", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000fcba", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000fd85", + "name": "", + "blocks": [ + { + "address": "0x14000fd85", + "size": 29, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fd85", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000fd86", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x14000fd87", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000fd88", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x14000fd8a", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x14000fd8c", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000fd8e", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14000fd90", + "size": 8, + "mnemonic": "lea", + "operands": "rbp, [rsp - 0x230]" + }, + { + "address": "0x14000fd98", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x330" + }, + { + "address": "0x14000fd9f", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x2129a]" + }, + { + "address": "0x14000fda6", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x14000fda9", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x220], rax" + }, + { + "address": "0x14000fdb0", + "size": 3, + "mnemonic": "xor", + "operands": "r13d, r13d" + }, + { + "address": "0x14000fdb3", + "size": 3, + "mnemonic": "movsxd", + "operands": "r12, edx" + }, + { + "address": "0x14000fdb6", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x40], r13d" + }, + { + "address": "0x14000fdbb", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r8" + }, + { + "address": "0x14000fdbe", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x14000fdc1", + "size": 5, + "mnemonic": "call", + "operands": "0x1400118c4" + }, + { + "address": "0x14000fdc6", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp + 0x70]" + }, + { + "address": "0x14000fdca", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x83" + }, + { + "address": "0x14000fdd0", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x60]" + }, + { + "address": "0x14000fdd5", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x14000fdd8", + "size": 7, + "mnemonic": "lea", + "operands": "r14, [rax + 0x2c8]" + }, + { + "address": "0x14000fddf", + "size": 5, + "mnemonic": "lea", + "operands": "rax, [rsp + 0x40]" + }, + { + "address": "0x14000fde4", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x14000fde9", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], 0x55" + }, + { + "address": "0x14000fdf2", + "size": 5, + "mnemonic": "call", + "operands": "0x14000f36c" + }, + { + "address": "0x14000fdf7", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000fdfa", + "size": 6, + "mnemonic": "je", + "operands": "0x140010021" + } + ], + "successors": [ + "0x140010021", + "0x14000fe00" + ] + }, + { + "address": "0x140010021", + "size": 14, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140010021", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140010023", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x220]" + }, + { + "address": "0x14001002a", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x14001002d", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140010032", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x388]" + }, + { + "address": "0x14001003a", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0x330" + }, + { + "address": "0x140010041", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140010043", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140010045", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140010047", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140010049", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001004a", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14001004b", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001004c", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000fe00", + "size": 16, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fe00", + "size": 3, + "mnemonic": "mov", + "operands": "r15, r12" + }, + { + "address": "0x14000fe03", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x60]" + }, + { + "address": "0x14000fe08", + "size": 4, + "mnemonic": "shl", + "operands": "r15, 5" + }, + { + "address": "0x14000fe0c", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r12" + }, + { + "address": "0x14000fe0f", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [r15 + rdi + 0x28]" + }, + { + "address": "0x14000fe14", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rax" + }, + { + "address": "0x14000fe17", + "size": 3, + "mnemonic": "sub", + "operands": "r9, rcx" + }, + { + "address": "0x14000fe1a", + "size": 3, + "mnemonic": "movzx", + "operands": "edx, word ptr [rcx]" + }, + { + "address": "0x14000fe1d", + "size": 5, + "mnemonic": "movzx", + "operands": "r8d, word ptr [rcx + r9]" + }, + { + "address": "0x14000fe22", + "size": 3, + "mnemonic": "sub", + "operands": "edx, r8d" + }, + { + "address": "0x14000fe25", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000fe30" + }, + { + "address": "0x14000fe27", + "size": 4, + "mnemonic": "add", + "operands": "rcx, 2" + }, + { + "address": "0x14000fe2b", + "size": 3, + "mnemonic": "test", + "operands": "r8d, r8d" + }, + { + "address": "0x14000fe2e", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000fe1a" + }, + { + "address": "0x14000fe30", + "size": 2, + "mnemonic": "test", + "operands": "edx, edx" + }, + { + "address": "0x14000fe32", + "size": 6, + "mnemonic": "je", + "operands": "0x140010023" + } + ], + "successors": [ + "0x140010023", + "0x14000fe38" + ] + }, + { + "address": "0x140010023", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140010023", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x220]" + }, + { + "address": "0x14001002a", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x14001002d", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140010032", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x388]" + }, + { + "address": "0x14001003a", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0x330" + }, + { + "address": "0x140010041", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140010043", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140010045", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140010047", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140010049", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001004a", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14001004b", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001004c", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000fe38", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fe38", + "size": 5, + "mnemonic": "lea", + "operands": "rax, [rsp + 0x60]" + }, + { + "address": "0x14000fe3d", + "size": 4, + "mnemonic": "or", + "operands": "rsi, 0xffffffffffffffff" + }, + { + "address": "0x14000fe41", + "size": 3, + "mnemonic": "inc", + "operands": "rsi" + }, + { + "address": "0x14000fe44", + "size": 5, + "mnemonic": "cmp", + "operands": "word ptr [rax + rsi*2], r13w" + }, + { + "address": "0x14000fe49", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000fe41" + }, + { + "address": "0x14000fe4b", + "size": 8, + "mnemonic": "lea", + "operands": "rcx, [rsi*2 + 6]" + }, + { + "address": "0x14000fe53", + "size": 5, + "mnemonic": "call", + "operands": "0x140015200" + }, + { + "address": "0x14000fe58", + "size": 3, + "mnemonic": "mov", + "operands": "r13, rax" + }, + { + "address": "0x14000fe5b", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000fe5e", + "size": 6, + "mnemonic": "je", + "operands": "0x140010021" + } + ], + "successors": [ + "0x140010021", + "0x14000fe64" + ] + }, + { + "address": "0x14000fe64", + "size": 21, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fe64", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r15 + rdi + 0x28]" + }, + { + "address": "0x14000fe69", + "size": 5, + "mnemonic": "lea", + "operands": "r8, [rsp + 0x60]" + }, + { + "address": "0x14000fe6e", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x48], rcx" + }, + { + "address": "0x14000fe73", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rsi + 1]" + }, + { + "address": "0x14000fe77", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdi + r12*8 + 0x128]" + }, + { + "address": "0x14000fe7f", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x50], rcx" + }, + { + "address": "0x14000fe84", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rdi + 0xc]" + }, + { + "address": "0x14000fe87", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x44], ecx" + }, + { + "address": "0x14000fe8b", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + 4]" + }, + { + "address": "0x14000fe8f", + "size": 5, + "mnemonic": "call", + "operands": "0x1400165b0" + }, + { + "address": "0x14000fe94", + "size": 2, + "mnemonic": "xor", + "operands": "esi, esi" + }, + { + "address": "0x14000fe96", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000fe98", + "size": 6, + "mnemonic": "jne", + "operands": "0x1400100d1" + }, + { + "address": "0x14000fe9e", + "size": 6, + "mnemonic": "cmp", + "operands": "word ptr [rsp + 0x60], 0x43" + }, + { + "address": "0x14000fea4", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r13 + 4]" + }, + { + "address": "0x14000fea8", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [r15 + rdi + 0x28], rax" + }, + { + "address": "0x14000fead", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000feba" + }, + { + "address": "0x14000feaf", + "size": 5, + "mnemonic": "cmp", + "operands": "word ptr [rsp + 0x62], si" + }, + { + "address": "0x14000feb4", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000feba" + }, + { + "address": "0x14000feb6", + "size": 2, + "mnemonic": "mov", + "operands": "eax, esi" + }, + { + "address": "0x14000feb8", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000fec3" + } + ], + "successors": [ + "0x14000fec3" + ] + }, + { + "address": "0x14000fec3", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fec3", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rdi + r12*8 + 0x128], rax" + }, + { + "address": "0x14000fecb", + "size": 4, + "mnemonic": "cmp", + "operands": "r12d, 2" + }, + { + "address": "0x14000fecf", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000ffb0" + }, + { + "address": "0x14000fed5", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [rsp + 0x40]" + }, + { + "address": "0x14000fed9", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, esi" + }, + { + "address": "0x14000fedc", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rdi + 0xc], eax" + }, + { + "address": "0x14000fedf", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x14000fee2", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r14 + 0x20]" + }, + { + "address": "0x14000fee6", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r14 + rdx*8]" + }, + { + "address": "0x14000feea", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rdi + 0xc], eax" + }, + { + "address": "0x14000feed", + "size": 2, + "mnemonic": "je", + "operands": "0x14000ff08" + } + ], + "successors": [ + "0x14000ff08", + "0x14000feef" + ] + }, + { + "address": "0x14000ff08", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ff08", + "size": 3, + "mnemonic": "test", + "operands": "r8d, r8d" + }, + { + "address": "0x14000ff0b", + "size": 2, + "mnemonic": "je", + "operands": "0x14000ff1b" + } + ], + "successors": [ + "0x14000ff1b", + "0x14000ff0d" + ] + }, + { + "address": "0x14000feef", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000feef", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [r14 + rdx*8]" + }, + { + "address": "0x14000fef3", + "size": 3, + "mnemonic": "inc", + "operands": "r8d" + }, + { + "address": "0x14000fef6", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r14 + rdx*8], rcx" + }, + { + "address": "0x14000fefa", + "size": 3, + "mnemonic": "inc", + "operands": "rdx" + }, + { + "address": "0x14000fefd", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x14000ff00", + "size": 4, + "mnemonic": "cmp", + "operands": "rdx, 5" + }, + { + "address": "0x14000ff04", + "size": 2, + "mnemonic": "jl", + "operands": "0x14000fee6" + } + ], + "successors": [ + "0x14000fee6", + "0x14000ff06" + ] + }, + { + "address": "0x14000ff1b", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ff1b", + "size": 4, + "mnemonic": "cmp", + "operands": "r8d, 5" + }, + { + "address": "0x14000ff1f", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000ffa7" + }, + { + "address": "0x14000ff25", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdi + 0xc]" + }, + { + "address": "0x14000ff28", + "size": 4, + "mnemonic": "lea", + "operands": "r9d, [r8 + 0x7a]" + }, + { + "address": "0x14000ff2c", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x30], 1" + }, + { + "address": "0x14000ff34", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip + 0x159f5]" + }, + { + "address": "0x14000ff3b", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], eax" + }, + { + "address": "0x14000ff3f", + "size": 4, + "mnemonic": "lea", + "operands": "edx, [r9 - 0x7e]" + }, + { + "address": "0x14000ff43", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x120]" + }, + { + "address": "0x14000ff4a", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14000ff4c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14000ff51", + "size": 5, + "mnemonic": "call", + "operands": "0x140016050" + }, + { + "address": "0x14000ff56", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, esi" + }, + { + "address": "0x14000ff58", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000ff5a", + "size": 2, + "mnemonic": "je", + "operands": "0x14000ff96" + } + ], + "successors": [ + "0x14000ff96", + "0x14000ff5c" + ] + }, + { + "address": "0x14000ff0d", + "size": 19, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ff0d", + "size": 3, + "mnemonic": "movsxd", + "operands": "rdx, r8d" + }, + { + "address": "0x14000ff10", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [r14 + rdx*8]" + }, + { + "address": "0x14000ff14", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [r14], rax" + }, + { + "address": "0x14000ff17", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r14 + rdx*8], rcx" + }, + { + "address": "0x14000ff1b", + "size": 4, + "mnemonic": "cmp", + "operands": "r8d, 5" + }, + { + "address": "0x14000ff1f", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000ffa7" + }, + { + "address": "0x14000ff25", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdi + 0xc]" + }, + { + "address": "0x14000ff28", + "size": 4, + "mnemonic": "lea", + "operands": "r9d, [r8 + 0x7a]" + }, + { + "address": "0x14000ff2c", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x30], 1" + }, + { + "address": "0x14000ff34", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip + 0x159f5]" + }, + { + "address": "0x14000ff3b", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], eax" + }, + { + "address": "0x14000ff3f", + "size": 4, + "mnemonic": "lea", + "operands": "edx, [r9 - 0x7e]" + }, + { + "address": "0x14000ff43", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x120]" + }, + { + "address": "0x14000ff4a", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14000ff4c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14000ff51", + "size": 5, + "mnemonic": "call", + "operands": "0x140016050" + }, + { + "address": "0x14000ff56", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, esi" + }, + { + "address": "0x14000ff58", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000ff5a", + "size": 2, + "mnemonic": "je", + "operands": "0x14000ff96" + } + ], + "successors": [ + "0x14000ff96", + "0x14000ff5c" + ] + }, + { + "address": "0x14000fee6", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fee6", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r14 + rdx*8]" + }, + { + "address": "0x14000feea", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rdi + 0xc], eax" + }, + { + "address": "0x14000feed", + "size": 2, + "mnemonic": "je", + "operands": "0x14000ff08" + } + ], + "successors": [ + "0x14000ff08", + "0x14000feef" + ] + }, + { + "address": "0x14000ff06", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ff06", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000ff1b" + } + ], + "successors": [ + "0x14000ff1b" + ] + }, + { + "address": "0x14000ff96", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ff96", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 4" + }, + { + "address": "0x14000ff9b", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r14" + }, + { + "address": "0x14000ff9e", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rdx + rax], ecx" + }, + { + "address": "0x14000ffa1", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdi + 0xc]" + }, + { + "address": "0x14000ffa4", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [r14], eax" + }, + { + "address": "0x14000ffa7", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r14 + 4]" + }, + { + "address": "0x14000ffab", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rdi + 0x1c], eax" + }, + { + "address": "0x14000ffae", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000ffcc" + } + ], + "successors": [ + "0x14000ffcc" + ] + }, + { + "address": "0x14000ff5c", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ff5c", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x120]" + }, + { + "address": "0x14000ff63", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0x1ff" + }, + { + "address": "0x14000ff68", + "size": 2, + "mnemonic": "inc", + "operands": "ecx" + }, + { + "address": "0x14000ff6a", + "size": 3, + "mnemonic": "and", + "operands": "word ptr [rax], dx" + }, + { + "address": "0x14000ff6d", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rax + 2]" + }, + { + "address": "0x14000ff71", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, 0x7f" + }, + { + "address": "0x14000ff74", + "size": 2, + "mnemonic": "jb", + "operands": "0x14000ff63" + } + ], + "successors": [ + "0x14000ff63", + "0x14000ff76" + ] + }, + { + "address": "0x14000ffcc", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ffcc", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x159ed]" + }, + { + "address": "0x14000ffd3", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x14000ffd6", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r12 + r12*2]" + }, + { + "address": "0x14000ffda", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdx + rax*8]" + }, + { + "address": "0x14000ffde", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3a0" + }, + { + "address": "0x14000ffe3", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000ffe5", + "size": 2, + "mnemonic": "je", + "operands": "0x14001004d" + } + ], + "successors": [ + "0x14001004d", + "0x14000ffe7" + ] + }, + { + "address": "0x14000ff63", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ff63", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0x1ff" + }, + { + "address": "0x14000ff68", + "size": 2, + "mnemonic": "inc", + "operands": "ecx" + }, + { + "address": "0x14000ff6a", + "size": 3, + "mnemonic": "and", + "operands": "word ptr [rax], dx" + }, + { + "address": "0x14000ff6d", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rax + 2]" + }, + { + "address": "0x14000ff71", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, 0x7f" + }, + { + "address": "0x14000ff74", + "size": 2, + "mnemonic": "jb", + "operands": "0x14000ff63" + } + ], + "successors": [ + "0x14000ff63", + "0x14000ff76" + ] + }, + { + "address": "0x14000ff76", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ff76", + "size": 7, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rip + 0x21333]" + }, + { + "address": "0x14000ff7d", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x120]" + }, + { + "address": "0x14000ff84", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0xfe" + }, + { + "address": "0x14000ff8a", + "size": 5, + "mnemonic": "call", + "operands": "0x14001ee30" + }, + { + "address": "0x14000ff8f", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000ff91", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, esi" + }, + { + "address": "0x14000ff93", + "size": 3, + "mnemonic": "sete", + "operands": "cl" + }, + { + "address": "0x14000ff96", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 4" + }, + { + "address": "0x14000ff9b", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r14" + }, + { + "address": "0x14000ff9e", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rdx + rax], ecx" + }, + { + "address": "0x14000ffa1", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdi + 0xc]" + }, + { + "address": "0x14000ffa4", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [r14], eax" + }, + { + "address": "0x14000ffa7", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r14 + 4]" + }, + { + "address": "0x14000ffab", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rdi + 0x1c], eax" + }, + { + "address": "0x14000ffae", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000ffcc" + } + ], + "successors": [ + "0x14000ffcc" + ] + }, + { + "address": "0x14001004d", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001004d", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x213e4]" + }, + { + "address": "0x140010054", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rsp + 0x48], rax" + }, + { + "address": "0x140010059", + "size": 2, + "mnemonic": "je", + "operands": "0x1400100af" + } + ], + "successors": [ + "0x1400100af", + "0x14001005b" + ] + }, + { + "address": "0x14000ffe7", + "size": 26, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000ffe7", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14000ffec", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x14000ffef", + "size": 4, + "mnemonic": "shl", + "operands": "rax, 5" + }, + { + "address": "0x14000fff3", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rax + rdi + 0x28], rcx" + }, + { + "address": "0x14000fff8", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdi + r12*8 + 0x128]" + }, + { + "address": "0x140010000", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140010005", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14001000a", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r13" + }, + { + "address": "0x14001000d", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rdi + r12*8 + 0x128], rax" + }, + { + "address": "0x140010015", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001001a", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [rsp + 0x44]" + }, + { + "address": "0x14001001e", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rdi + 0xc], eax" + }, + { + "address": "0x140010021", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140010023", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x220]" + }, + { + "address": "0x14001002a", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x14001002d", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140010032", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x388]" + }, + { + "address": "0x14001003a", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0x330" + }, + { + "address": "0x140010041", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140010043", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140010045", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140010047", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140010049", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001004a", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14001004b", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001004c", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400100af", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400100af", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x1400100b2", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [r13], 1" + }, + { + "address": "0x1400100ba", + "size": 4, + "mnemonic": "shl", + "operands": "rcx, 5" + }, + { + "address": "0x1400100be", + "size": 4, + "mnemonic": "shl", + "operands": "rbx, 5" + }, + { + "address": "0x1400100c2", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rcx + rdi + 0x38], r13" + }, + { + "address": "0x1400100c7", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx + rdi + 0x28]" + }, + { + "address": "0x1400100cc", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140010023" + } + ], + "successors": [ + "0x140010023" + ] + }, + { + "address": "0x14001005b", + "size": 26, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001005b", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x14001005e", + "size": 4, + "mnemonic": "shl", + "operands": "rdx, 5" + }, + { + "address": "0x140010062", + "size": 3, + "mnemonic": "or", + "operands": "ecx, 0xffffffff" + }, + { + "address": "0x140010065", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdx + rdi + 0x38]" + }, + { + "address": "0x14001006a", + "size": 4, + "mnemonic": "lock xadd", + "operands": "dword ptr [rax], ecx" + }, + { + "address": "0x14001006e", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, 1" + }, + { + "address": "0x140010071", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400100af" + }, + { + "address": "0x140010073", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdx + rdi + 0x38]" + }, + { + "address": "0x140010078", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001007d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140010080", + "size": 4, + "mnemonic": "shl", + "operands": "rcx, 5" + }, + { + "address": "0x140010084", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + rdi + 0x30]" + }, + { + "address": "0x140010089", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001008e", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdi + r12*8 + 0x128]" + }, + { + "address": "0x140010096", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001009b", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x14001009e", + "size": 4, + "mnemonic": "shl", + "operands": "rcx, 5" + }, + { + "address": "0x1400100a2", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rcx + rdi + 0x28], rsi" + }, + { + "address": "0x1400100a7", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rdi + r12*8 + 0x128], rsi" + }, + { + "address": "0x1400100af", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x1400100b2", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [r13], 1" + }, + { + "address": "0x1400100ba", + "size": 4, + "mnemonic": "shl", + "operands": "rcx, 5" + }, + { + "address": "0x1400100be", + "size": 4, + "mnemonic": "shl", + "operands": "rbx, 5" + }, + { + "address": "0x1400100c2", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rcx + rdi + 0x38], r13" + }, + { + "address": "0x1400100c7", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx + rdi + 0x28]" + }, + { + "address": "0x1400100cc", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140010023" + } + ], + "successors": [ + "0x140010023" + ] + } + ] + }, + { + "address": "0x1400100ed", + "name": "", + "blocks": [ + { + "address": "0x1400100ed", + "size": 26, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400100ed", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x1400100ee", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x1400100ef", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x1400100f0", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x1400100f2", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x1400100f4", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x1400100f6", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x1400100f8", + "size": 5, + "mnemonic": "lea", + "operands": "rbp, [rsp - 0x27]" + }, + { + "address": "0x1400100fd", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x90" + }, + { + "address": "0x140010104", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x20f35]" + }, + { + "address": "0x14001010b", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x14001010e", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x17], rax" + }, + { + "address": "0x140010112", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rdx" + }, + { + "address": "0x140010115", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x1ca" + }, + { + "address": "0x14001011b", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14001011d", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140010120", + "size": 5, + "mnemonic": "call", + "operands": "0x14001ea80" + }, + { + "address": "0x140010125", + "size": 3, + "mnemonic": "xor", + "operands": "r13d, r13d" + }, + { + "address": "0x140010128", + "size": 4, + "mnemonic": "lea", + "operands": "r12, [rbp - 0x41]" + }, + { + "address": "0x14001012c", + "size": 3, + "mnemonic": "mov", + "operands": "edi, r13d" + }, + { + "address": "0x14001012f", + "size": 4, + "mnemonic": "lea", + "operands": "esi, [r13 + 1]" + }, + { + "address": "0x140010133", + "size": 3, + "mnemonic": "mov", + "operands": "r15d, r13d" + }, + { + "address": "0x140010136", + "size": 4, + "mnemonic": "cmp", + "operands": "rdi, 4" + }, + { + "address": "0x14001013a", + "size": 6, + "mnemonic": "jae", + "operands": "0x1400102ba" + }, + { + "address": "0x140010140", + "size": 4, + "mnemonic": "cmp", + "operands": "r15d, 2" + }, + { + "address": "0x140010144", + "size": 2, + "mnemonic": "je", + "operands": "0x140010157" + } + ], + "successors": [ + "0x140010157", + "0x140010146" + ] + }, + { + "address": "0x140010157", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010157", + "size": 4, + "mnemonic": "or", + "operands": "rax, 0xffffffffffffffff" + }, + { + "address": "0x14001015b", + "size": 3, + "mnemonic": "inc", + "operands": "rax" + }, + { + "address": "0x14001015e", + "size": 5, + "mnemonic": "cmp", + "operands": "word ptr [r14 + rax*2], r13w" + }, + { + "address": "0x140010163", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001015b" + }, + { + "address": "0x140010165", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [r12 - 8], r14" + }, + { + "address": "0x14001016a", + "size": 3, + "mnemonic": "add", + "operands": "rdi, rsi" + }, + { + "address": "0x14001016d", + "size": 4, + "mnemonic": "lea", + "operands": "r14, [r14 + rax*2]" + }, + { + "address": "0x140010171", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r12], rax" + }, + { + "address": "0x140010175", + "size": 4, + "mnemonic": "movzx", + "operands": "eax, word ptr [r14]" + }, + { + "address": "0x140010179", + "size": 4, + "mnemonic": "add", + "operands": "r14, 2" + }, + { + "address": "0x14001017d", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [r12 + 8], r15d" + }, + { + "address": "0x140010182", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, eax" + }, + { + "address": "0x140010184", + "size": 4, + "mnemonic": "add", + "operands": "r12, 0x18" + }, + { + "address": "0x140010188", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001018a", + "size": 2, + "mnemonic": "je", + "operands": "0x14001019a" + } + ], + "successors": [ + "0x14001019a", + "0x14001018c" + ] + }, + { + "address": "0x140010146", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010146", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x15983]" + }, + { + "address": "0x14001014d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r14" + }, + { + "address": "0x140010150", + "size": 5, + "mnemonic": "call", + "operands": "0x14001a500" + }, + { + "address": "0x140010155", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140010165" + } + ], + "successors": [ + "0x140010165" + ] + }, + { + "address": "0x14001019a", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001019a", + "size": 3, + "mnemonic": "sub", + "operands": "rdi, rsi" + }, + { + "address": "0x14001019d", + "size": 6, + "mnemonic": "je", + "operands": "0x1400102ac" + } + ], + "successors": [ + "0x1400102ac", + "0x1400101a3" + ] + }, + { + "address": "0x14001018c", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001018c", + "size": 3, + "mnemonic": "sub", + "operands": "ecx, 0x2d" + }, + { + "address": "0x14001018f", + "size": 2, + "mnemonic": "je", + "operands": "0x140010133" + } + ], + "successors": [ + "0x140010133", + "0x140010191" + ] + }, + { + "address": "0x140010165", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010165", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [r12 - 8], r14" + }, + { + "address": "0x14001016a", + "size": 3, + "mnemonic": "add", + "operands": "rdi, rsi" + }, + { + "address": "0x14001016d", + "size": 4, + "mnemonic": "lea", + "operands": "r14, [r14 + rax*2]" + }, + { + "address": "0x140010171", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r12], rax" + }, + { + "address": "0x140010175", + "size": 4, + "mnemonic": "movzx", + "operands": "eax, word ptr [r14]" + }, + { + "address": "0x140010179", + "size": 4, + "mnemonic": "add", + "operands": "r14, 2" + }, + { + "address": "0x14001017d", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [r12 + 8], r15d" + }, + { + "address": "0x140010182", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, eax" + }, + { + "address": "0x140010184", + "size": 4, + "mnemonic": "add", + "operands": "r12, 0x18" + }, + { + "address": "0x140010188", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001018a", + "size": 2, + "mnemonic": "je", + "operands": "0x14001019a" + } + ], + "successors": [ + "0x14001019a", + "0x14001018c" + ] + }, + { + "address": "0x1400102ac", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400102ac", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x49]" + }, + { + "address": "0x1400102b0", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x1400102b3", + "size": 5, + "mnemonic": "call", + "operands": "0x14001032c" + }, + { + "address": "0x1400102b8", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400102bc" + } + ], + "successors": [ + "0x1400102bc" + ] + }, + { + "address": "0x1400101a3", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400101a3", + "size": 3, + "mnemonic": "sub", + "operands": "rdi, rsi" + }, + { + "address": "0x1400101a6", + "size": 6, + "mnemonic": "je", + "operands": "0x140010264" + } + ], + "successors": [ + "0x140010264", + "0x1400101ac" + ] + }, + { + "address": "0x140010133", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010133", + "size": 3, + "mnemonic": "mov", + "operands": "r15d, r13d" + }, + { + "address": "0x140010136", + "size": 4, + "mnemonic": "cmp", + "operands": "rdi, 4" + }, + { + "address": "0x14001013a", + "size": 6, + "mnemonic": "jae", + "operands": "0x1400102ba" + }, + { + "address": "0x140010140", + "size": 4, + "mnemonic": "cmp", + "operands": "r15d, 2" + }, + { + "address": "0x140010144", + "size": 2, + "mnemonic": "je", + "operands": "0x140010157" + } + ], + "successors": [ + "0x140010157", + "0x140010146" + ] + }, + { + "address": "0x140010191", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010191", + "size": 2, + "mnemonic": "sub", + "operands": "ecx, esi" + }, + { + "address": "0x140010193", + "size": 2, + "mnemonic": "je", + "operands": "0x1400101ff" + } + ], + "successors": [ + "0x1400101ff", + "0x140010195" + ] + }, + { + "address": "0x1400102bc", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400102bc", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x17]" + }, + { + "address": "0x1400102c0", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x1400102c3", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x1400102c8", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0xe0]" + }, + { + "address": "0x1400102d0", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0x90" + }, + { + "address": "0x1400102d7", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x1400102d9", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x1400102db", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x1400102dd", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x1400102df", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400102e0", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x1400102e1", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x1400102e2", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140010264", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010264", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x49]" + }, + { + "address": "0x140010268", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x14001026b", + "size": 5, + "mnemonic": "call", + "operands": "0x14001032c" + }, + { + "address": "0x140010270", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x140010272", + "size": 2, + "mnemonic": "je", + "operands": "0x1400102a4" + } + ], + "successors": [ + "0x1400102a4", + "0x140010274" + ] + }, + { + "address": "0x1400101ac", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400101ac", + "size": 3, + "mnemonic": "sub", + "operands": "rdi, rsi" + }, + { + "address": "0x1400101af", + "size": 2, + "mnemonic": "je", + "operands": "0x14001020a" + } + ], + "successors": [ + "0x14001020a", + "0x1400101b1" + ] + }, + { + "address": "0x1400101ff", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400101ff", + "size": 6, + "mnemonic": "mov", + "operands": "r15d, 2" + }, + { + "address": "0x140010205", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140010136" + } + ], + "successors": [ + "0x140010136" + ] + }, + { + "address": "0x140010195", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010195", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, 0x31" + }, + { + "address": "0x140010198", + "size": 2, + "mnemonic": "je", + "operands": "0x140010133" + } + ], + "successors": [ + "0x140010133", + "0x14001019a" + ] + }, + { + "address": "0x1400102a4", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400102a4", + "size": 3, + "mnemonic": "mov", + "operands": "sil, r13b" + }, + { + "address": "0x1400102a7", + "size": 3, + "mnemonic": "mov", + "operands": "al, sil" + }, + { + "address": "0x1400102aa", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400102bc" + } + ], + "successors": [ + "0x1400102bc" + ] + }, + { + "address": "0x140010274", + "size": 18, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010274", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x31]" + }, + { + "address": "0x140010278", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x14001027b", + "size": 5, + "mnemonic": "call", + "operands": "0x1400104ac" + }, + { + "address": "0x140010280", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x140010282", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400102a7" + }, + { + "address": "0x140010284", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x31]" + }, + { + "address": "0x140010288", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x14001028b", + "size": 5, + "mnemonic": "call", + "operands": "0x1400103b8" + }, + { + "address": "0x140010290", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x140010292", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400102a7" + }, + { + "address": "0x140010294", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x31]" + }, + { + "address": "0x140010298", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x14001029b", + "size": 5, + "mnemonic": "call", + "operands": "0x1400102e4" + }, + { + "address": "0x1400102a0", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x1400102a2", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400102a7" + }, + { + "address": "0x1400102a4", + "size": 3, + "mnemonic": "mov", + "operands": "sil, r13b" + }, + { + "address": "0x1400102a7", + "size": 3, + "mnemonic": "mov", + "operands": "al, sil" + }, + { + "address": "0x1400102aa", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400102bc" + } + ], + "successors": [ + "0x1400102bc" + ] + }, + { + "address": "0x14001020a", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001020a", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x49]" + }, + { + "address": "0x14001020e", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140010211", + "size": 5, + "mnemonic": "call", + "operands": "0x14001032c" + }, + { + "address": "0x140010216", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x140010218", + "size": 6, + "mnemonic": "je", + "operands": "0x1400102a4" + } + ], + "successors": [ + "0x1400102a4", + "0x14001021e" + ] + }, + { + "address": "0x1400101b1", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400101b1", + "size": 3, + "mnemonic": "cmp", + "operands": "rdi, rsi" + }, + { + "address": "0x1400101b4", + "size": 6, + "mnemonic": "jne", + "operands": "0x1400102ba" + }, + { + "address": "0x1400101ba", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x49]" + }, + { + "address": "0x1400101be", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x1400101c1", + "size": 5, + "mnemonic": "call", + "operands": "0x14001032c" + }, + { + "address": "0x1400101c6", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x1400101c8", + "size": 6, + "mnemonic": "je", + "operands": "0x1400102a4" + } + ], + "successors": [ + "0x1400102a4", + "0x1400101ce" + ] + }, + { + "address": "0x140010136", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010136", + "size": 4, + "mnemonic": "cmp", + "operands": "rdi, 4" + }, + { + "address": "0x14001013a", + "size": 6, + "mnemonic": "jae", + "operands": "0x1400102ba" + }, + { + "address": "0x140010140", + "size": 4, + "mnemonic": "cmp", + "operands": "r15d, 2" + }, + { + "address": "0x140010144", + "size": 2, + "mnemonic": "je", + "operands": "0x140010157" + } + ], + "successors": [ + "0x140010157", + "0x140010146" + ] + }, + { + "address": "0x14001021e", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001021e", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x31]" + }, + { + "address": "0x140010222", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140010225", + "size": 5, + "mnemonic": "call", + "operands": "0x1400104ac" + }, + { + "address": "0x14001022a", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x14001022c", + "size": 2, + "mnemonic": "je", + "operands": "0x14001024e" + } + ], + "successors": [ + "0x14001024e", + "0x14001022e" + ] + }, + { + "address": "0x1400101ce", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400101ce", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x31]" + }, + { + "address": "0x1400101d2", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x1400101d5", + "size": 5, + "mnemonic": "call", + "operands": "0x1400104ac" + }, + { + "address": "0x1400101da", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x1400101dc", + "size": 6, + "mnemonic": "je", + "operands": "0x1400102a4" + } + ], + "successors": [ + "0x1400102a4", + "0x1400101e2" + ] + }, + { + "address": "0x14001024e", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001024e", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x31]" + }, + { + "address": "0x140010252", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140010255", + "size": 5, + "mnemonic": "call", + "operands": "0x1400103b8" + }, + { + "address": "0x14001025a", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x14001025c", + "size": 2, + "mnemonic": "je", + "operands": "0x1400102a4" + } + ], + "successors": [ + "0x1400102a4", + "0x14001025e" + ] + }, + { + "address": "0x14001022e", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001022e", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x19]" + }, + { + "address": "0x140010232", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140010235", + "size": 5, + "mnemonic": "call", + "operands": "0x1400103b8" + }, + { + "address": "0x14001023a", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x14001023c", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400102a7" + }, + { + "address": "0x14001023e", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x19]" + }, + { + "address": "0x140010242", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140010245", + "size": 5, + "mnemonic": "call", + "operands": "0x1400102e4" + }, + { + "address": "0x14001024a", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x14001024c", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400102a7" + }, + { + "address": "0x14001024e", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x31]" + }, + { + "address": "0x140010252", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140010255", + "size": 5, + "mnemonic": "call", + "operands": "0x1400103b8" + }, + { + "address": "0x14001025a", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x14001025c", + "size": 2, + "mnemonic": "je", + "operands": "0x1400102a4" + } + ], + "successors": [ + "0x1400102a4", + "0x14001025e" + ] + }, + { + "address": "0x1400101e2", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400101e2", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x19]" + }, + { + "address": "0x1400101e6", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x1400101e9", + "size": 5, + "mnemonic": "call", + "operands": "0x1400103b8" + }, + { + "address": "0x1400101ee", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x1400101f0", + "size": 6, + "mnemonic": "je", + "operands": "0x1400102a4" + } + ], + "successors": [ + "0x1400102a4", + "0x1400101f6" + ] + }, + { + "address": "0x14001025e", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001025e", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x19]" + }, + { + "address": "0x140010262", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140010298" + } + ], + "successors": [ + "0x140010298" + ] + }, + { + "address": "0x1400101f6", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400101f6", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 1]" + }, + { + "address": "0x1400101fa", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140010298" + } + ], + "successors": [ + "0x140010298" + ] + }, + { + "address": "0x140010298", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010298", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x14001029b", + "size": 5, + "mnemonic": "call", + "operands": "0x1400102e4" + }, + { + "address": "0x1400102a0", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x1400102a2", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400102a7" + }, + { + "address": "0x1400102a4", + "size": 3, + "mnemonic": "mov", + "operands": "sil, r13b" + }, + { + "address": "0x1400102a7", + "size": 3, + "mnemonic": "mov", + "operands": "al, sil" + }, + { + "address": "0x1400102aa", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400102bc" + } + ], + "successors": [ + "0x1400102bc" + ] + } + ] + }, + { + "address": "0x1400109ba", + "name": "", + "blocks": [ + { + "address": "0x1400109ba", + "size": 18, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400109ba", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x1400109bb", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x1400109be", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x1400109c2", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x10]" + }, + { + "address": "0x1400109c6", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x18], rax" + }, + { + "address": "0x1400109ca", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp + 0x28]" + }, + { + "address": "0x1400109ce", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x18]" + }, + { + "address": "0x1400109d2", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x10], rax" + }, + { + "address": "0x1400109d6", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbp - 0x18]" + }, + { + "address": "0x1400109da", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 2" + }, + { + "address": "0x1400109df", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x20]" + }, + { + "address": "0x1400109e3", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x20]" + }, + { + "address": "0x1400109e7", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp + 0x28], eax" + }, + { + "address": "0x1400109ea", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x20], eax" + }, + { + "address": "0x1400109ed", + "size": 5, + "mnemonic": "call", + "operands": "0x1400105f4" + }, + { + "address": "0x1400109f2", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x40" + }, + { + "address": "0x1400109f6", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x1400109f7", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140010c1a", + "name": "", + "blocks": [ + { + "address": "0x140010c1a", + "size": 20, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010c1a", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140010c1b", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140010c1c", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140010c1d", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140010c1f", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140010c21", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140010c23", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140010c25", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0xa0" + }, + { + "address": "0x140010c2c", + "size": 3, + "mnemonic": "mov", + "operands": "r12, qword ptr [rdx]" + }, + { + "address": "0x140010c2f", + "size": 3, + "mnemonic": "xor", + "operands": "r13d, r13d" + }, + { + "address": "0x140010c32", + "size": 4, + "mnemonic": "movzx", + "operands": "esi, r9b" + }, + { + "address": "0x140010c36", + "size": 3, + "mnemonic": "mov", + "operands": "r15d, r8d" + }, + { + "address": "0x140010c39", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x90], r12" + }, + { + "address": "0x140010c41", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x140010c44", + "size": 3, + "mnemonic": "test", + "operands": "r12, r12" + }, + { + "address": "0x140010c47", + "size": 2, + "mnemonic": "jne", + "operands": "0x140010c5b" + }, + { + "address": "0x140010c49", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x140010c4e", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0x16" + }, + { + "address": "0x140010c54", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afb4" + }, + { + "address": "0x140010c59", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140010c8d" + } + ], + "successors": [ + "0x140010c8d" + ] + }, + { + "address": "0x140010c8d", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010c8d", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdi + 8]" + }, + { + "address": "0x140010c91", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140010c94", + "size": 6, + "mnemonic": "je", + "operands": "0x140011308" + } + ], + "successors": [ + "0x140011308", + "0x140010c9a" + ] + }, + { + "address": "0x140011308", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011308", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001130a", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14001138f" + } + ], + "successors": [ + "0x14001138f" + ] + }, + { + "address": "0x140010c9a", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010c9a", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdi]" + }, + { + "address": "0x140010c9d", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rcx], rax" + }, + { + "address": "0x140010ca0", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140011308" + } + ], + "successors": [ + "0x140011308" + ] + }, + { + "address": "0x14001138f", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001138f", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0xf0]" + }, + { + "address": "0x140011397", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0xa0" + }, + { + "address": "0x14001139e", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x1400113a0", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x1400113a2", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x1400113a4", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x1400113a6", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400113a7", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x1400113a8", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x1400113a9", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400113b6", + "name": "", + "blocks": [ + { + "address": "0x1400113b6", + "size": 27, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400113b6", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x1400113b7", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x1400113ba", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x70" + }, + { + "address": "0x1400113be", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rbp - 0x40], 0" + }, + { + "address": "0x1400113c3", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x21e26], 0" + }, + { + "address": "0x1400113ca", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x30], 0" + }, + { + "address": "0x1400113ce", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 0" + }, + { + "address": "0x1400113d2", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x1400113d6", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x1400113da", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400113ec" + }, + { + "address": "0x1400113dc", + "size": 7, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rip + 0x20045]" + }, + { + "address": "0x1400113e3", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 1" + }, + { + "address": "0x1400113e7", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp - 0x28], xmm0" + }, + { + "address": "0x1400113ec", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rbp - 0x48], 0" + }, + { + "address": "0x1400113f1", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x50]" + }, + { + "address": "0x1400113f5", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x50], rcx" + }, + { + "address": "0x1400113f9", + "size": 3, + "mnemonic": "mov", + "operands": "r9b, 1" + }, + { + "address": "0x1400113fc", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x140011400", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0xa" + }, + { + "address": "0x140011406", + "size": 5, + "mnemonic": "call", + "operands": "0x140010c10" + }, + { + "address": "0x14001140b", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x18], 2" + }, + { + "address": "0x14001140f", + "size": 2, + "mnemonic": "mov", + "operands": "edi, eax" + }, + { + "address": "0x140011411", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001141e" + }, + { + "address": "0x140011413", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x40]" + }, + { + "address": "0x140011417", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rcx + 0x3a8], 0xfffffffd" + }, + { + "address": "0x14001141e", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x140011422", + "size": 2, + "mnemonic": "je", + "operands": "0x140011433" + } + ], + "successors": [ + "0x140011433", + "0x140011424" + ] + }, + { + "address": "0x140011433", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011433", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x140011437", + "size": 2, + "mnemonic": "je", + "operands": "0x140011448" + } + ], + "successors": [ + "0x140011448", + "0x140011439" + ] + }, + { + "address": "0x140011424", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011424", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0x14]" + }, + { + "address": "0x140011427", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x14001142b", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x140011430", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x20], ebx" + }, + { + "address": "0x140011433", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x140011437", + "size": 2, + "mnemonic": "je", + "operands": "0x140011448" + } + ], + "successors": [ + "0x140011448", + "0x140011439" + ] + }, + { + "address": "0x140011448", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140011448", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x70]" + }, + { + "address": "0x14001144d", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x14001144f", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x10]" + }, + { + "address": "0x140011453", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x18]" + }, + { + "address": "0x140011457", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x14001145a", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001145b", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140011439", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140011439", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0xc]" + }, + { + "address": "0x14001143c", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x140011440", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x140011445", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x24], ebx" + }, + { + "address": "0x140011448", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x70]" + }, + { + "address": "0x14001144d", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x14001144f", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x10]" + }, + { + "address": "0x140011453", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x18]" + }, + { + "address": "0x140011457", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x14001145a", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001145b", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400115bc", + "name": "", + "blocks": [ + { + "address": "0x1400115bc", + "size": 48, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400115bc", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x1400115be", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x1400115c1", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x50" + }, + { + "address": "0x1400115c5", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x28], rcx" + }, + { + "address": "0x1400115c9", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp - 0x28]" + }, + { + "address": "0x1400115cd", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x18], rax" + }, + { + "address": "0x1400115d1", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp + 0x20]" + }, + { + "address": "0x1400115d5", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 1" + }, + { + "address": "0x1400115da", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbp - 0x18]" + }, + { + "address": "0x1400115de", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 5" + }, + { + "address": "0x1400115e3", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp + 0x20], eax" + }, + { + "address": "0x1400115e6", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp + 0x28], eax" + }, + { + "address": "0x1400115e9", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp - 0x28]" + }, + { + "address": "0x1400115ed", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x10], rax" + }, + { + "address": "0x1400115f1", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp - 0x20]" + }, + { + "address": "0x1400115f5", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 8], rax" + }, + { + "address": "0x1400115f9", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 4" + }, + { + "address": "0x1400115fe", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x30], eax" + }, + { + "address": "0x140011601", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x2c], eax" + }, + { + "address": "0x140011604", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x21c2d]" + }, + { + "address": "0x14001160b", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x20], rax" + }, + { + "address": "0x14001160f", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rcx + 0x28], edx" + }, + { + "address": "0x140011612", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x14197]" + }, + { + "address": "0x140011619", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp - 0x28]" + }, + { + "address": "0x14001161d", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rax], rcx" + }, + { + "address": "0x140011620", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x20119]" + }, + { + "address": "0x140011627", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp - 0x28]" + }, + { + "address": "0x14001162b", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x3a8], edx" + }, + { + "address": "0x140011631", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp - 0x28]" + }, + { + "address": "0x140011635", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x88], rcx" + }, + { + "address": "0x14001163c", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rdx + 0x42]" + }, + { + "address": "0x14001163f", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp - 0x28]" + }, + { + "address": "0x140011643", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp + 0x28]" + }, + { + "address": "0x140011647", + "size": 7, + "mnemonic": "mov", + "operands": "word ptr [rax + 0xbc], cx" + }, + { + "address": "0x14001164e", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp - 0x28]" + }, + { + "address": "0x140011652", + "size": 7, + "mnemonic": "mov", + "operands": "word ptr [rax + 0x1c2], cx" + }, + { + "address": "0x140011659", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x18]" + }, + { + "address": "0x14001165d", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp - 0x28]" + }, + { + "address": "0x140011661", + "size": 8, + "mnemonic": "and", + "operands": "qword ptr [rax + 0x3a0], 0" + }, + { + "address": "0x140011669", + "size": 5, + "mnemonic": "call", + "operands": "0x140011494" + }, + { + "address": "0x14001166e", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp - 0x30]" + }, + { + "address": "0x140011672", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbp - 0x10]" + }, + { + "address": "0x140011676", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x2c]" + }, + { + "address": "0x14001167a", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x18]" + }, + { + "address": "0x14001167e", + "size": 5, + "mnemonic": "call", + "operands": "0x140011514" + }, + { + "address": "0x140011683", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x50" + }, + { + "address": "0x140011687", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140011688", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400116ac", + "name": "", + "blocks": [ + { + "address": "0x1400116ac", + "size": 18, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400116ac", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x1400116ae", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x1400116b1", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x1400116b5", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp - 0x18]" + }, + { + "address": "0x1400116b9", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x18], rcx" + }, + { + "address": "0x1400116bd", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x10], rax" + }, + { + "address": "0x1400116c1", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x140e8]" + }, + { + "address": "0x1400116c8", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 5" + }, + { + "address": "0x1400116cd", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp + 0x20], eax" + }, + { + "address": "0x1400116d0", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp + 0x28], eax" + }, + { + "address": "0x1400116d3", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp - 0x18]" + }, + { + "address": "0x1400116d7", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 8], rax" + }, + { + "address": "0x1400116db", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 4" + }, + { + "address": "0x1400116e0", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x20], eax" + }, + { + "address": "0x1400116e3", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x1c], eax" + }, + { + "address": "0x1400116e6", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x1400116e9", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, rdx" + }, + { + "address": "0x1400116ec", + "size": 2, + "mnemonic": "je", + "operands": "0x1400116fa" + } + ], + "successors": [ + "0x1400116fa", + "0x1400116ee" + ] + }, + { + "address": "0x1400116fa", + "size": 39, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400116fa", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x70]" + }, + { + "address": "0x1400116fe", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140011703", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x18]" + }, + { + "address": "0x140011707", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x58]" + }, + { + "address": "0x14001170b", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140011710", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x18]" + }, + { + "address": "0x140011714", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x60]" + }, + { + "address": "0x140011718", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001171d", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x18]" + }, + { + "address": "0x140011721", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x68]" + }, + { + "address": "0x140011725", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001172a", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x18]" + }, + { + "address": "0x14001172e", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x48]" + }, + { + "address": "0x140011732", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140011737", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x18]" + }, + { + "address": "0x14001173b", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x50]" + }, + { + "address": "0x14001173f", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140011744", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x18]" + }, + { + "address": "0x140011748", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x78]" + }, + { + "address": "0x14001174c", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140011751", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x18]" + }, + { + "address": "0x140011755", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x80]" + }, + { + "address": "0x14001175c", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140011761", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x18]" + }, + { + "address": "0x140011765", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x3c0]" + }, + { + "address": "0x14001176c", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140011771", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp + 0x20]" + }, + { + "address": "0x140011775", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbp - 0x10]" + }, + { + "address": "0x140011779", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp + 0x28]" + }, + { + "address": "0x14001177d", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x18]" + }, + { + "address": "0x140011781", + "size": 5, + "mnemonic": "call", + "operands": "0x14001155c" + }, + { + "address": "0x140011786", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp - 0x20]" + }, + { + "address": "0x14001178a", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbp - 8]" + }, + { + "address": "0x14001178e", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x1c]" + }, + { + "address": "0x140011792", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x18]" + }, + { + "address": "0x140011796", + "size": 5, + "mnemonic": "call", + "operands": "0x1400114d4" + }, + { + "address": "0x14001179b", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x40" + }, + { + "address": "0x14001179f", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x1400117a0", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400116ee", + "size": 42, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400116ee", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x1400116f1", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x1400116f6", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x18]" + }, + { + "address": "0x1400116fa", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x70]" + }, + { + "address": "0x1400116fe", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140011703", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x18]" + }, + { + "address": "0x140011707", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x58]" + }, + { + "address": "0x14001170b", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140011710", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x18]" + }, + { + "address": "0x140011714", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x60]" + }, + { + "address": "0x140011718", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001171d", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x18]" + }, + { + "address": "0x140011721", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x68]" + }, + { + "address": "0x140011725", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001172a", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x18]" + }, + { + "address": "0x14001172e", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x48]" + }, + { + "address": "0x140011732", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140011737", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x18]" + }, + { + "address": "0x14001173b", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x50]" + }, + { + "address": "0x14001173f", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140011744", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x18]" + }, + { + "address": "0x140011748", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x78]" + }, + { + "address": "0x14001174c", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140011751", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x18]" + }, + { + "address": "0x140011755", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x80]" + }, + { + "address": "0x14001175c", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140011761", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x18]" + }, + { + "address": "0x140011765", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x3c0]" + }, + { + "address": "0x14001176c", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140011771", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp + 0x20]" + }, + { + "address": "0x140011775", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbp - 0x10]" + }, + { + "address": "0x140011779", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp + 0x28]" + }, + { + "address": "0x14001177d", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x18]" + }, + { + "address": "0x140011781", + "size": 5, + "mnemonic": "call", + "operands": "0x14001155c" + }, + { + "address": "0x140011786", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp - 0x20]" + }, + { + "address": "0x14001178a", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbp - 8]" + }, + { + "address": "0x14001178e", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x1c]" + }, + { + "address": "0x140011792", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x18]" + }, + { + "address": "0x140011796", + "size": 5, + "mnemonic": "call", + "operands": "0x1400114d4" + }, + { + "address": "0x14001179b", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x40" + }, + { + "address": "0x14001179f", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x1400117a0", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140012ca7", + "name": "", + "blocks": [ + { + "address": "0x140012ca7", + "size": 67, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140012ca7", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140012ca8", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140012ca9", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140012caa", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140012cac", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140012cae", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140012cb0", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140012cb2", + "size": 4, + "mnemonic": "lea", + "operands": "rbp, [rax - 0x57]" + }, + { + "address": "0x140012cb6", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0xd0" + }, + { + "address": "0x140012cbd", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 9], 0xfffffffffffffffe" + }, + { + "address": "0x140012cc5", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 8], rbx" + }, + { + "address": "0x140012cc9", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x1e370]" + }, + { + "address": "0x140012cd0", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x140012cd3", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x17], rax" + }, + { + "address": "0x140012cd7", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, r8" + }, + { + "address": "0x140012cda", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x41], r8" + }, + { + "address": "0x140012cde", + "size": 3, + "mnemonic": "movsxd", + "operands": "r14, edx" + }, + { + "address": "0x140012ce1", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140012ce4", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x7f]" + }, + { + "address": "0x140012ce8", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x59], rax" + }, + { + "address": "0x140012cec", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r14" + }, + { + "address": "0x140012cef", + "size": 3, + "mnemonic": "mov", + "operands": "r13, r14" + }, + { + "address": "0x140012cf2", + "size": 4, + "mnemonic": "sar", + "operands": "r13, 6" + }, + { + "address": "0x140012cf6", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x39], r13" + }, + { + "address": "0x140012cfa", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip - 0x12d01]" + }, + { + "address": "0x140012d01", + "size": 3, + "mnemonic": "and", + "operands": "eax, 0x3f" + }, + { + "address": "0x140012d04", + "size": 4, + "mnemonic": "lea", + "operands": "r15, [rax + rax*8]" + }, + { + "address": "0x140012d08", + "size": 8, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + r13*8 + 0x33300]" + }, + { + "address": "0x140012d10", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax + r15*8 + 0x28]" + }, + { + "address": "0x140012d15", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x19], rax" + }, + { + "address": "0x140012d19", + "size": 3, + "mnemonic": "mov", + "operands": "r12d, r9d" + }, + { + "address": "0x140012d1c", + "size": 3, + "mnemonic": "add", + "operands": "r12, r8" + }, + { + "address": "0x140012d1f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x61], r12" + }, + { + "address": "0x140012d23", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xd4d7]" + }, + { + "address": "0x140012d29", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x49], eax" + }, + { + "address": "0x140012d2c", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x140012d2e", + "size": 4, + "mnemonic": "mov", + "operands": "r10, qword ptr [rbp - 0x59]" + }, + { + "address": "0x140012d32", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [r10 + 0x28], dil" + }, + { + "address": "0x140012d36", + "size": 2, + "mnemonic": "jne", + "operands": "0x140012d44" + }, + { + "address": "0x140012d38", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r10" + }, + { + "address": "0x140012d3b", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d940" + }, + { + "address": "0x140012d40", + "size": 4, + "mnemonic": "mov", + "operands": "r10, qword ptr [rbp - 0x59]" + }, + { + "address": "0x140012d44", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r10 + 0x18]" + }, + { + "address": "0x140012d48", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rcx + 0xc]" + }, + { + "address": "0x140012d4b", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x45], ecx" + }, + { + "address": "0x140012d4e", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140012d50", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rbx], rax" + }, + { + "address": "0x140012d53", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 8], eax" + }, + { + "address": "0x140012d56", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [rbp - 0x41], r12" + }, + { + "address": "0x140012d5a", + "size": 6, + "mnemonic": "jae", + "operands": "0x14001310d" + }, + { + "address": "0x140012d60", + "size": 3, + "mnemonic": "mov", + "operands": "r11, r14" + }, + { + "address": "0x140012d63", + "size": 4, + "mnemonic": "sar", + "operands": "r11, 6" + }, + { + "address": "0x140012d67", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x11], r11" + }, + { + "address": "0x140012d6b", + "size": 2, + "mnemonic": "mov", + "operands": "edx, edi" + }, + { + "address": "0x140012d6d", + "size": 2, + "mnemonic": "mov", + "operands": "al, byte ptr [rsi]" + }, + { + "address": "0x140012d6f", + "size": 3, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x71], al" + }, + { + "address": "0x140012d72", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x6d], edi" + }, + { + "address": "0x140012d75", + "size": 6, + "mnemonic": "mov", + "operands": "r12d, 1" + }, + { + "address": "0x140012d7b", + "size": 6, + "mnemonic": "cmp", + "operands": "ecx, 0xfde9" + }, + { + "address": "0x140012d81", + "size": 6, + "mnemonic": "jne", + "operands": "0x140012f14" + }, + { + "address": "0x140012d87", + "size": 2, + "mnemonic": "mov", + "operands": "edx, edi" + }, + { + "address": "0x140012d89", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rdi" + }, + { + "address": "0x140012d8c", + "size": 7, + "mnemonic": "lea", + "operands": "r12, [rip - 0x12d93]" + }, + { + "address": "0x140012d93", + "size": 8, + "mnemonic": "lea", + "operands": "rcx, [r15*8 + 0x3e]" + }, + { + "address": "0x140012d9b", + "size": 8, + "mnemonic": "add", + "operands": "rcx, qword ptr [r12 + r11*8 + 0x33300]" + }, + { + "address": "0x140012da3", + "size": 3, + "mnemonic": "cmp", + "operands": "byte ptr [rcx], dil" + }, + { + "address": "0x140012da6", + "size": 2, + "mnemonic": "je", + "operands": "0x140012db6" + } + ], + "successors": [ + "0x140012db6", + "0x140012da8" + ] + }, + { + "address": "0x140012db6", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140012db6", + "size": 3, + "mnemonic": "test", + "operands": "r14, r14" + }, + { + "address": "0x140012db9", + "size": 6, + "mnemonic": "jle", + "operands": "0x140012eaa" + }, + { + "address": "0x140012dbf", + "size": 8, + "mnemonic": "mov", + "operands": "rax, qword ptr [r12 + r13*8 + 0x33300]" + }, + { + "address": "0x140012dc7", + "size": 6, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rax + r15*8 + 0x3e]" + }, + { + "address": "0x140012dcd", + "size": 9, + "mnemonic": "movsx", + "operands": "r12d, byte ptr [rcx + r12 + 0x31490]" + }, + { + "address": "0x140012dd6", + "size": 3, + "mnemonic": "inc", + "operands": "r12d" + }, + { + "address": "0x140012dd9", + "size": 3, + "mnemonic": "mov", + "operands": "eax, r12d" + }, + { + "address": "0x140012ddc", + "size": 2, + "mnemonic": "sub", + "operands": "eax, edx" + }, + { + "address": "0x140012dde", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x51], eax" + }, + { + "address": "0x140012de1", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [rbp - 0x61]" + }, + { + "address": "0x140012de5", + "size": 3, + "mnemonic": "sub", + "operands": "r8, rsi" + }, + { + "address": "0x140012de8", + "size": 3, + "mnemonic": "movsxd", + "operands": "r9, eax" + }, + { + "address": "0x140012deb", + "size": 3, + "mnemonic": "cmp", + "operands": "r9, r8" + }, + { + "address": "0x140012dee", + "size": 6, + "mnemonic": "jg", + "operands": "0x140013081" + } + ], + "successors": [ + "0x140013081", + "0x140012df4" + ] + }, + { + "address": "0x140012da8", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140012da8", + "size": 2, + "mnemonic": "inc", + "operands": "edx" + }, + { + "address": "0x140012daa", + "size": 3, + "mnemonic": "inc", + "operands": "r14" + }, + { + "address": "0x140012dad", + "size": 3, + "mnemonic": "inc", + "operands": "rcx" + }, + { + "address": "0x140012db0", + "size": 4, + "mnemonic": "cmp", + "operands": "r14, 5" + }, + { + "address": "0x140012db4", + "size": 2, + "mnemonic": "jl", + "operands": "0x140012da3" + } + ], + "successors": [ + "0x140012da3", + "0x140012db6" + ] + }, + { + "address": "0x140013081", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140013081", + "size": 3, + "mnemonic": "test", + "operands": "r8, r8" + }, + { + "address": "0x140013084", + "size": 2, + "mnemonic": "jle", + "operands": "0x1400130b1" + }, + { + "address": "0x140013086", + "size": 3, + "mnemonic": "sub", + "operands": "rsi, r14" + }, + { + "address": "0x140013089", + "size": 7, + "mnemonic": "lea", + "operands": "r9, [rip - 0x13090]" + }, + { + "address": "0x140013090", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [r14 + r15*8]" + }, + { + "address": "0x140013094", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r9 + r13*8 + 0x33300]" + }, + { + "address": "0x14001309c", + "size": 4, + "mnemonic": "mov", + "operands": "al, byte ptr [rsi + r14]" + }, + { + "address": "0x1400130a0", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rdx + rcx + 0x3e], al" + }, + { + "address": "0x1400130a4", + "size": 2, + "mnemonic": "inc", + "operands": "edi" + }, + { + "address": "0x1400130a6", + "size": 3, + "mnemonic": "inc", + "operands": "r14" + }, + { + "address": "0x1400130a9", + "size": 3, + "mnemonic": "movsxd", + "operands": "rax, edi" + }, + { + "address": "0x1400130ac", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, r8" + }, + { + "address": "0x1400130af", + "size": 2, + "mnemonic": "jl", + "operands": "0x140013090" + } + ], + "successors": [ + "0x140013090", + "0x1400130b1" + ] + }, + { + "address": "0x140012df4", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140012df4", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140012df7", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip - 0x12dfe]" + }, + { + "address": "0x140012dfe", + "size": 8, + "mnemonic": "lea", + "operands": "rdx, [r15*8 + 0x3e]" + }, + { + "address": "0x140012e06", + "size": 8, + "mnemonic": "add", + "operands": "rdx, qword ptr [r8 + r11*8 + 0x33300]" + }, + { + "address": "0x140012e0e", + "size": 2, + "mnemonic": "mov", + "operands": "al, byte ptr [rdx]" + }, + { + "address": "0x140012e10", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp + rcx - 1], al" + }, + { + "address": "0x140012e14", + "size": 3, + "mnemonic": "inc", + "operands": "rcx" + }, + { + "address": "0x140012e17", + "size": 3, + "mnemonic": "inc", + "operands": "rdx" + }, + { + "address": "0x140012e1a", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, r14" + }, + { + "address": "0x140012e1d", + "size": 2, + "mnemonic": "jl", + "operands": "0x140012e0e" + } + ], + "successors": [ + "0x140012e0e", + "0x140012e1f" + ] + }, + { + "address": "0x140012da3", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140012da3", + "size": 3, + "mnemonic": "cmp", + "operands": "byte ptr [rcx], dil" + }, + { + "address": "0x140012da6", + "size": 2, + "mnemonic": "je", + "operands": "0x140012db6" + } + ], + "successors": [ + "0x140012db6", + "0x140012da8" + ] + }, + { + "address": "0x140013090", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140013090", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [r14 + r15*8]" + }, + { + "address": "0x140013094", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r9 + r13*8 + 0x33300]" + }, + { + "address": "0x14001309c", + "size": 4, + "mnemonic": "mov", + "operands": "al, byte ptr [rsi + r14]" + }, + { + "address": "0x1400130a0", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rdx + rcx + 0x3e], al" + }, + { + "address": "0x1400130a4", + "size": 2, + "mnemonic": "inc", + "operands": "edi" + }, + { + "address": "0x1400130a6", + "size": 3, + "mnemonic": "inc", + "operands": "r14" + }, + { + "address": "0x1400130a9", + "size": 3, + "mnemonic": "movsxd", + "operands": "rax, edi" + }, + { + "address": "0x1400130ac", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, r8" + }, + { + "address": "0x1400130af", + "size": 2, + "mnemonic": "jl", + "operands": "0x140013090" + } + ], + "successors": [ + "0x140013090", + "0x1400130b1" + ] + }, + { + "address": "0x1400130b1", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400130b1", + "size": 4, + "mnemonic": "add", + "operands": "dword ptr [rbx + 4], r8d" + }, + { + "address": "0x1400130b5", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001310d" + } + ], + "successors": [ + "0x14001310d" + ] + }, + { + "address": "0x140012e0e", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140012e0e", + "size": 2, + "mnemonic": "mov", + "operands": "al, byte ptr [rdx]" + }, + { + "address": "0x140012e10", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp + rcx - 1], al" + }, + { + "address": "0x140012e14", + "size": 3, + "mnemonic": "inc", + "operands": "rcx" + }, + { + "address": "0x140012e17", + "size": 3, + "mnemonic": "inc", + "operands": "rdx" + }, + { + "address": "0x140012e1a", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, r14" + }, + { + "address": "0x140012e1d", + "size": 2, + "mnemonic": "jl", + "operands": "0x140012e0e" + } + ], + "successors": [ + "0x140012e0e", + "0x140012e1f" + ] + }, + { + "address": "0x140012e1f", + "size": 16, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140012e1f", + "size": 3, + "mnemonic": "test", + "operands": "r9, r9" + }, + { + "address": "0x140012e22", + "size": 2, + "mnemonic": "jle", + "operands": "0x140012e41" + }, + { + "address": "0x140012e24", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 1]" + }, + { + "address": "0x140012e28", + "size": 3, + "mnemonic": "add", + "operands": "rcx, r14" + }, + { + "address": "0x140012e2b", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r9" + }, + { + "address": "0x140012e2e", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x140012e31", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3e0" + }, + { + "address": "0x140012e36", + "size": 4, + "mnemonic": "mov", + "operands": "r10, qword ptr [rbp - 0x59]" + }, + { + "address": "0x140012e3a", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip - 0x12e41]" + }, + { + "address": "0x140012e41", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rdi" + }, + { + "address": "0x140012e44", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rdx + r15*8]" + }, + { + "address": "0x140012e48", + "size": 8, + "mnemonic": "mov", + "operands": "rax, qword ptr [r8 + r13*8 + 0x33300]" + }, + { + "address": "0x140012e50", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rcx + rax + 0x3e], dil" + }, + { + "address": "0x140012e55", + "size": 3, + "mnemonic": "inc", + "operands": "rdx" + }, + { + "address": "0x140012e58", + "size": 3, + "mnemonic": "cmp", + "operands": "rdx, r14" + }, + { + "address": "0x140012e5b", + "size": 2, + "mnemonic": "jl", + "operands": "0x140012e44" + } + ], + "successors": [ + "0x140012e44", + "0x140012e5d" + ] + }, + { + "address": "0x14001310d", + "size": 14, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001310d", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140013110", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x17]" + }, + { + "address": "0x140013114", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x140013117", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x14001311c", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x110]" + }, + { + "address": "0x140013124", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0xd0" + }, + { + "address": "0x14001312b", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14001312d", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001312f", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140013131", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140013133", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140013134", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140013135", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140013136", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140012e44", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140012e44", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rdx + r15*8]" + }, + { + "address": "0x140012e48", + "size": 8, + "mnemonic": "mov", + "operands": "rax, qword ptr [r8 + r13*8 + 0x33300]" + }, + { + "address": "0x140012e50", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rcx + rax + 0x3e], dil" + }, + { + "address": "0x140012e55", + "size": 3, + "mnemonic": "inc", + "operands": "rdx" + }, + { + "address": "0x140012e58", + "size": 3, + "mnemonic": "cmp", + "operands": "rdx, r14" + }, + { + "address": "0x140012e5b", + "size": 2, + "mnemonic": "jl", + "operands": "0x140012e44" + } + ], + "successors": [ + "0x140012e44", + "0x140012e5d" + ] + }, + { + "address": "0x140012e5d", + "size": 16, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140012e5d", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x31], rdi" + }, + { + "address": "0x140012e61", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp - 1]" + }, + { + "address": "0x140012e65", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x29], rax" + }, + { + "address": "0x140012e69", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x140012e6b", + "size": 4, + "mnemonic": "cmp", + "operands": "r12d, 4" + }, + { + "address": "0x140012e6f", + "size": 3, + "mnemonic": "sete", + "operands": "al" + }, + { + "address": "0x140012e72", + "size": 2, + "mnemonic": "inc", + "operands": "eax" + }, + { + "address": "0x140012e74", + "size": 3, + "mnemonic": "mov", + "operands": "r12d, eax" + }, + { + "address": "0x140012e77", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, eax" + }, + { + "address": "0x140012e7a", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r10" + }, + { + "address": "0x140012e7f", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp - 0x31]" + }, + { + "address": "0x140012e83", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x29]" + }, + { + "address": "0x140012e87", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x6d]" + }, + { + "address": "0x140012e8b", + "size": 5, + "mnemonic": "call", + "operands": "0x140016e74" + }, + { + "address": "0x140012e90", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, -1" + }, + { + "address": "0x140012e94", + "size": 6, + "mnemonic": "je", + "operands": "0x14001310d" + } + ], + "successors": [ + "0x14001310d", + "0x140012e9a" + ] + }, + { + "address": "0x140012e9a", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140012e9a", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbp - 0x51]" + }, + { + "address": "0x140012e9d", + "size": 2, + "mnemonic": "dec", + "operands": "eax" + }, + { + "address": "0x140012e9f", + "size": 3, + "mnemonic": "movsxd", + "operands": "rcx, eax" + }, + { + "address": "0x140012ea2", + "size": 3, + "mnemonic": "add", + "operands": "rsi, rcx" + }, + { + "address": "0x140012ea5", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140012fac" + } + ], + "successors": [ + "0x140012fac" + ] + }, + { + "address": "0x140012fac", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140012fac", + "size": 3, + "mnemonic": "inc", + "operands": "rsi" + }, + { + "address": "0x140012faf", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], rdi" + }, + { + "address": "0x140012fb4", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rdi" + }, + { + "address": "0x140012fb9", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], 5" + }, + { + "address": "0x140012fc1", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 0xf]" + }, + { + "address": "0x140012fc5", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x140012fca", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, r12d" + }, + { + "address": "0x140012fcd", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbp - 0x6d]" + }, + { + "address": "0x140012fd1", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140012fd3", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbp - 0x49]" + }, + { + "address": "0x140012fd6", + "size": 5, + "mnemonic": "call", + "operands": "0x1400170bc" + }, + { + "address": "0x140012fdb", + "size": 3, + "mnemonic": "mov", + "operands": "r14d, eax" + }, + { + "address": "0x140012fde", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140012fe0", + "size": 6, + "mnemonic": "je", + "operands": "0x14001310d" + } + ], + "successors": [ + "0x14001310d", + "0x140012fe6" + ] + }, + { + "address": "0x140012fe6", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140012fe6", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x69], edi" + }, + { + "address": "0x140012fe9", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rdi" + }, + { + "address": "0x140012fee", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp - 0x69]" + }, + { + "address": "0x140012ff2", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, eax" + }, + { + "address": "0x140012ff5", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp + 0xf]" + }, + { + "address": "0x140012ff9", + "size": 4, + "mnemonic": "mov", + "operands": "r12, qword ptr [rbp - 0x19]" + }, + { + "address": "0x140012ffd", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r12" + }, + { + "address": "0x140013000", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xd14a]" + }, + { + "address": "0x140013006", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140013008", + "size": 6, + "mnemonic": "je", + "operands": "0x140013105" + } + ], + "successors": [ + "0x140013105", + "0x14001300e" + ] + }, + { + "address": "0x140013105", + "size": 16, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140013105", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xcfed]" + }, + { + "address": "0x14001310b", + "size": 2, + "mnemonic": "mov", + "operands": "dword ptr [rbx], eax" + }, + { + "address": "0x14001310d", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140013110", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x17]" + }, + { + "address": "0x140013114", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x140013117", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x14001311c", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x110]" + }, + { + "address": "0x140013124", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0xd0" + }, + { + "address": "0x14001312b", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14001312d", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001312f", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140013131", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140013133", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140013134", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140013135", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140013136", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001300e", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001300e", + "size": 3, + "mnemonic": "mov", + "operands": "edx, dword ptr [rbx + 8]" + }, + { + "address": "0x140013011", + "size": 3, + "mnemonic": "sub", + "operands": "edx, dword ptr [rbp - 0x41]" + }, + { + "address": "0x140013014", + "size": 2, + "mnemonic": "add", + "operands": "edx, esi" + }, + { + "address": "0x140013016", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 4], edx" + }, + { + "address": "0x140013019", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rbp - 0x69], r14d" + }, + { + "address": "0x14001301d", + "size": 6, + "mnemonic": "jb", + "operands": "0x14001310d" + } + ], + "successors": [ + "0x14001310d", + "0x140013023" + ] + }, + { + "address": "0x140013023", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140013023", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x71], 0xa" + }, + { + "address": "0x140013027", + "size": 2, + "mnemonic": "jne", + "operands": "0x140013067" + }, + { + "address": "0x140013029", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0xd" + }, + { + "address": "0x14001302e", + "size": 4, + "mnemonic": "mov", + "operands": "word ptr [rbp - 0x71], ax" + }, + { + "address": "0x140013032", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rdi" + }, + { + "address": "0x140013037", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp - 0x69]" + }, + { + "address": "0x14001303b", + "size": 4, + "mnemonic": "lea", + "operands": "r8d, [rax - 0xc]" + }, + { + "address": "0x14001303f", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x71]" + }, + { + "address": "0x140013043", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r12" + }, + { + "address": "0x140013046", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xd104]" + }, + { + "address": "0x14001304c", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001304e", + "size": 6, + "mnemonic": "je", + "operands": "0x140013105" + } + ], + "successors": [ + "0x140013105", + "0x140013054" + ] + }, + { + "address": "0x140013054", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140013054", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rbp - 0x69], 1" + }, + { + "address": "0x140013058", + "size": 6, + "mnemonic": "jb", + "operands": "0x14001310d" + } + ], + "successors": [ + "0x14001310d", + "0x14001305e" + ] + }, + { + "address": "0x14001305e", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001305e", + "size": 3, + "mnemonic": "inc", + "operands": "dword ptr [rbx + 8]" + }, + { + "address": "0x140013061", + "size": 3, + "mnemonic": "inc", + "operands": "dword ptr [rbx + 4]" + }, + { + "address": "0x140013064", + "size": 3, + "mnemonic": "mov", + "operands": "edx, dword ptr [rbx + 4]" + }, + { + "address": "0x140013067", + "size": 4, + "mnemonic": "cmp", + "operands": "rsi, qword ptr [rbp - 0x61]" + }, + { + "address": "0x14001306b", + "size": 6, + "mnemonic": "jae", + "operands": "0x14001310d" + }, + { + "address": "0x140013071", + "size": 4, + "mnemonic": "mov", + "operands": "r10, qword ptr [rbp - 0x59]" + }, + { + "address": "0x140013075", + "size": 4, + "mnemonic": "mov", + "operands": "r11, qword ptr [rbp - 0x11]" + }, + { + "address": "0x140013079", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbp - 0x45]" + }, + { + "address": "0x14001307c", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140012d6d" + } + ], + "successors": [ + "0x140012d6d" + ] + }, + { + "address": "0x140012d6d", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140012d6d", + "size": 2, + "mnemonic": "mov", + "operands": "al, byte ptr [rsi]" + }, + { + "address": "0x140012d6f", + "size": 3, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x71], al" + }, + { + "address": "0x140012d72", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x6d], edi" + }, + { + "address": "0x140012d75", + "size": 6, + "mnemonic": "mov", + "operands": "r12d, 1" + }, + { + "address": "0x140012d7b", + "size": 6, + "mnemonic": "cmp", + "operands": "ecx, 0xfde9" + }, + { + "address": "0x140012d81", + "size": 6, + "mnemonic": "jne", + "operands": "0x140012f14" + }, + { + "address": "0x140012d87", + "size": 2, + "mnemonic": "mov", + "operands": "edx, edi" + }, + { + "address": "0x140012d89", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rdi" + }, + { + "address": "0x140012d8c", + "size": 7, + "mnemonic": "lea", + "operands": "r12, [rip - 0x12d93]" + }, + { + "address": "0x140012d93", + "size": 8, + "mnemonic": "lea", + "operands": "rcx, [r15*8 + 0x3e]" + }, + { + "address": "0x140012d9b", + "size": 8, + "mnemonic": "add", + "operands": "rcx, qword ptr [r12 + r11*8 + 0x33300]" + }, + { + "address": "0x140012da3", + "size": 3, + "mnemonic": "cmp", + "operands": "byte ptr [rcx], dil" + }, + { + "address": "0x140012da6", + "size": 2, + "mnemonic": "je", + "operands": "0x140012db6" + } + ], + "successors": [ + "0x140012db6", + "0x140012da8" + ] + } + ] + }, + { + "address": "0x1400135f0", + "name": "", + "blocks": [ + { + "address": "0x1400135f0", + "size": 17, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400135f0", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x1400135f2", + "size": 1, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x1400135f3", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x1400135f4", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x1400135f5", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x1400135f7", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x1400135f9", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x1400135fb", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x1400135fd", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x140013600", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x68" + }, + { + "address": "0x140013604", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x140013606", + "size": 3, + "mnemonic": "mov", + "operands": "r14d, r8d" + }, + { + "address": "0x140013609", + "size": 3, + "mnemonic": "movsxd", + "operands": "r13, ecx" + }, + { + "address": "0x14001360c", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r9" + }, + { + "address": "0x14001360f", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rdx" + }, + { + "address": "0x140013612", + "size": 3, + "mnemonic": "test", + "operands": "r8d, r8d" + }, + { + "address": "0x140013615", + "size": 6, + "mnemonic": "je", + "operands": "0x14001390c" + } + ], + "successors": [ + "0x14001390c", + "0x14001361b" + ] + }, + { + "address": "0x14001390c", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001390c", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001390e", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x68" + }, + { + "address": "0x140013912", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140013914", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140013916", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140013918", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14001391a", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001391b", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14001391c", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001391d", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001391e", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001361b", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001361b", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14001361e", + "size": 2, + "mnemonic": "jne", + "operands": "0x140013657" + }, + { + "address": "0x140013620", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [r9 + 0x38], 1" + }, + { + "address": "0x140013625", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x140013628", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r9 + 0x34], edi" + }, + { + "address": "0x14001362c", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14001362e", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [r9 + 0x30], 1" + }, + { + "address": "0x140013633", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x140013635", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [r9 + 0x2c], 0x16" + }, + { + "address": "0x14001363d", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x140013640", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rbx" + }, + { + "address": "0x140013645", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rdi" + }, + { + "address": "0x14001364a", + "size": 5, + "mnemonic": "call", + "operands": "0x14000aefc" + }, + { + "address": "0x14001364f", + "size": 3, + "mnemonic": "or", + "operands": "eax, 0xffffffff" + }, + { + "address": "0x140013652", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14001390e" + } + ], + "successors": [ + "0x14001390e" + ] + }, + { + "address": "0x14001390e", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001390e", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x68" + }, + { + "address": "0x140013912", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140013914", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140013916", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140013918", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14001391a", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001391b", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14001391c", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001391d", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001391e", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140013c57", + "name": "", + "blocks": [ + { + "address": "0x140013c57", + "size": 30, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140013c57", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140013c58", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140013c59", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140013c5a", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140013c5c", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140013c5e", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140013c60", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140013c62", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140013c66", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rdx" + }, + { + "address": "0x140013c69", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140013c6c", + "size": 5, + "mnemonic": "call", + "operands": "0x140012934" + }, + { + "address": "0x140013c71", + "size": 3, + "mnemonic": "movsxd", + "operands": "r12, eax" + }, + { + "address": "0x140013c74", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x1f685]" + }, + { + "address": "0x140013c7b", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x140013c7d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r12" + }, + { + "address": "0x140013c80", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0x3f" + }, + { + "address": "0x140013c83", + "size": 3, + "mnemonic": "mov", + "operands": "r15d, edi" + }, + { + "address": "0x140013c86", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r12" + }, + { + "address": "0x140013c89", + "size": 4, + "mnemonic": "sar", + "operands": "rax, 6" + }, + { + "address": "0x140013c8d", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x60], rax" + }, + { + "address": "0x140013c92", + "size": 4, + "mnemonic": "lea", + "operands": "r13, [rcx + rcx*8]" + }, + { + "address": "0x140013c96", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdx + rax*8]" + }, + { + "address": "0x140013c9a", + "size": 5, + "mnemonic": "mov", + "operands": "sil, byte ptr [rax + r13*8 + 0x39]" + }, + { + "address": "0x140013c9f", + "size": 4, + "mnemonic": "cmp", + "operands": "sil, 1" + }, + { + "address": "0x140013ca3", + "size": 4, + "mnemonic": "sete", + "operands": "r15b" + }, + { + "address": "0x140013ca7", + "size": 3, + "mnemonic": "inc", + "operands": "r15" + }, + { + "address": "0x140013caa", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rbx + 0x10], edi" + }, + { + "address": "0x140013cad", + "size": 2, + "mnemonic": "jne", + "operands": "0x140013cb7" + }, + { + "address": "0x140013caf", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r14" + }, + { + "address": "0x140013cb2", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140013d8e" + } + ], + "successors": [ + "0x140013d8e" + ] + }, + { + "address": "0x140013d8e", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140013d8e", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x68]" + }, + { + "address": "0x140013d93", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140013d97", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140013d99", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140013d9b", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140013d9d", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140013d9f", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140013da0", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140013da1", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140013da2", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140013da9", + "name": "", + "blocks": [ + { + "address": "0x140013da9", + "size": 23, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140013da9", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140013daa", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140013dab", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140013dac", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140013dae", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140013db0", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140013db2", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140013db4", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x1050" + }, + { + "address": "0x140013db9", + "size": 5, + "mnemonic": "call", + "operands": "0x1400057a0" + }, + { + "address": "0x140013dbe", + "size": 3, + "mnemonic": "sub", + "operands": "rsp, rax" + }, + { + "address": "0x140013dc1", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x1d278]" + }, + { + "address": "0x140013dc8", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x140013dcb", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x1040], rax" + }, + { + "address": "0x140013dd3", + "size": 3, + "mnemonic": "mov", + "operands": "r15, r8" + }, + { + "address": "0x140013dd6", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x140013dd9", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140013ddc", + "size": 5, + "mnemonic": "call", + "operands": "0x140012934" + }, + { + "address": "0x140013de1", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x140013de3", + "size": 3, + "mnemonic": "movsxd", + "operands": "r14, eax" + }, + { + "address": "0x140013de6", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rbx + 0x10], edi" + }, + { + "address": "0x140013de9", + "size": 2, + "mnemonic": "jne", + "operands": "0x140013df3" + }, + { + "address": "0x140013deb", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbp" + }, + { + "address": "0x140013dee", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140013eff" + } + ], + "successors": [ + "0x140013eff" + ] + }, + { + "address": "0x140013eff", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140013eff", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x1040]" + }, + { + "address": "0x140013f07", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x140013f0a", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140013f0f", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x1090]" + }, + { + "address": "0x140013f17", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0x1050" + }, + { + "address": "0x140013f1e", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140013f20", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140013f22", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140013f24", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140013f26", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140013f27", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140013f28", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140013f29", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140013f8e", + "name": "", + "blocks": [ + { + "address": "0x140013f8e", + "size": 22, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140013f8e", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140013f8f", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x140013f92", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x140013f96", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rbp - 0x40], 0" + }, + { + "address": "0x140013f9b", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x1f24e], 0" + }, + { + "address": "0x140013fa2", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x30], 0" + }, + { + "address": "0x140013fa6", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 0" + }, + { + "address": "0x140013faa", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x140013fae", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x140013fb2", + "size": 2, + "mnemonic": "jne", + "operands": "0x140013fc4" + }, + { + "address": "0x140013fb4", + "size": 7, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rip + 0x1d46d]" + }, + { + "address": "0x140013fbb", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 1" + }, + { + "address": "0x140013fbf", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp - 0x28], xmm0" + }, + { + "address": "0x140013fc4", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x40]" + }, + { + "address": "0x140013fc8", + "size": 5, + "mnemonic": "call", + "operands": "0x140013a8c" + }, + { + "address": "0x140013fcd", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x18], 2" + }, + { + "address": "0x140013fd1", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rax" + }, + { + "address": "0x140013fd4", + "size": 2, + "mnemonic": "jne", + "operands": "0x140013fe1" + }, + { + "address": "0x140013fd6", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x40]" + }, + { + "address": "0x140013fda", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rcx + 0x3a8], 0xfffffffd" + }, + { + "address": "0x140013fe1", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x140013fe5", + "size": 2, + "mnemonic": "je", + "operands": "0x140013ff6" + } + ], + "successors": [ + "0x140013ff6", + "0x140013fe7" + ] + }, + { + "address": "0x140013ff6", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140013ff6", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x140013ffa", + "size": 2, + "mnemonic": "je", + "operands": "0x14001400b" + } + ], + "successors": [ + "0x14001400b", + "0x140013ffc" + ] + }, + { + "address": "0x140013fe7", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140013fe7", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0x14]" + }, + { + "address": "0x140013fea", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x140013fee", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x140013ff3", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x20], ebx" + }, + { + "address": "0x140013ff6", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x140013ffa", + "size": 2, + "mnemonic": "je", + "operands": "0x14001400b" + } + ], + "successors": [ + "0x14001400b", + "0x140013ffc" + ] + }, + { + "address": "0x14001400b", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001400b", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140014010", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdi" + }, + { + "address": "0x140014013", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x78]" + }, + { + "address": "0x140014018", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x14001401c", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001401d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140013ffc", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140013ffc", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0xc]" + }, + { + "address": "0x140013fff", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x140014003", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x140014008", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x24], ebx" + }, + { + "address": "0x14001400b", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140014010", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdi" + }, + { + "address": "0x140014013", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x78]" + }, + { + "address": "0x140014018", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x14001401c", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001401d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140014279", + "name": "", + "blocks": [ + { + "address": "0x140014279", + "size": 23, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140014279", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001427a", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x14001427b", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001427c", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x14001427e", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140014280", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140014282", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140014284", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x140014288", + "size": 3, + "mnemonic": "movsxd", + "operands": "r15, ecx" + }, + { + "address": "0x14001428b", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x14001428d", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r15" + }, + { + "address": "0x140014290", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x1f069]" + }, + { + "address": "0x140014297", + "size": 3, + "mnemonic": "and", + "operands": "eax, 0x3f" + }, + { + "address": "0x14001429a", + "size": 3, + "mnemonic": "mov", + "operands": "r12, r15" + }, + { + "address": "0x14001429d", + "size": 4, + "mnemonic": "sar", + "operands": "r12, 6" + }, + { + "address": "0x1400142a1", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rdx" + }, + { + "address": "0x1400142a4", + "size": 4, + "mnemonic": "lea", + "operands": "r9d, [rdi + 0xa]" + }, + { + "address": "0x1400142a8", + "size": 3, + "mnemonic": "mov", + "operands": "r14, r15" + }, + { + "address": "0x1400142ab", + "size": 4, + "mnemonic": "lea", + "operands": "rbp, [rax + rax*8]" + }, + { + "address": "0x1400142af", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + r12*8]" + }, + { + "address": "0x1400142b3", + "size": 5, + "mnemonic": "mov", + "operands": "r10, qword ptr [rax + rbp*8 + 0x28]" + }, + { + "address": "0x1400142b8", + "size": 3, + "mnemonic": "test", + "operands": "r8, r8" + }, + { + "address": "0x1400142bb", + "size": 2, + "mnemonic": "je", + "operands": "0x1400142ca" + } + ], + "successors": [ + "0x1400142ca", + "0x1400142bd" + ] + }, + { + "address": "0x1400142ca", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400142ca", + "size": 5, + "mnemonic": "and", + "operands": "byte ptr [rax + rbp*8 + 0x38], 0xfb" + }, + { + "address": "0x1400142cf", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rdx + r8*2]" + }, + { + "address": "0x1400142d3", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsi" + }, + { + "address": "0x1400142d6", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rsi" + }, + { + "address": "0x1400142d9", + "size": 3, + "mnemonic": "cmp", + "operands": "rsi, r8" + }, + { + "address": "0x1400142dc", + "size": 6, + "mnemonic": "jae", + "operands": "0x14001444e" + }, + { + "address": "0x1400142e2", + "size": 6, + "mnemonic": "mov", + "operands": "r11d, 0xd" + }, + { + "address": "0x1400142e8", + "size": 4, + "mnemonic": "lea", + "operands": "r13d, [r11 - 0xb]" + }, + { + "address": "0x1400142ec", + "size": 3, + "mnemonic": "movzx", + "operands": "edx, word ptr [rax]" + }, + { + "address": "0x1400142ef", + "size": 4, + "mnemonic": "cmp", + "operands": "dx, 0x1a" + }, + { + "address": "0x1400142f3", + "size": 6, + "mnemonic": "je", + "operands": "0x140014419" + } + ], + "successors": [ + "0x140014419", + "0x1400142f9" + ] + }, + { + "address": "0x1400142bd", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400142bd", + "size": 4, + "mnemonic": "cmp", + "operands": "word ptr [rdx], r9w" + }, + { + "address": "0x1400142c1", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400142ca" + }, + { + "address": "0x1400142c3", + "size": 5, + "mnemonic": "or", + "operands": "byte ptr [rax + rbp*8 + 0x38], 4" + }, + { + "address": "0x1400142c8", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400142cf" + } + ], + "successors": [ + "0x1400142cf" + ] + }, + { + "address": "0x140014419", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140014419", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r15" + }, + { + "address": "0x14001441c", + "size": 7, + "mnemonic": "lea", + "operands": "r9, [rip + 0x1eedd]" + }, + { + "address": "0x140014423", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0x3f" + }, + { + "address": "0x140014426", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r15" + }, + { + "address": "0x140014429", + "size": 4, + "mnemonic": "sar", + "operands": "rax, 6" + }, + { + "address": "0x14001442d", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rcx + rcx*8]" + }, + { + "address": "0x140014431", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r9 + rax*8]" + }, + { + "address": "0x140014435", + "size": 5, + "mnemonic": "mov", + "operands": "al, byte ptr [rcx + r8*8 + 0x38]" + }, + { + "address": "0x14001443a", + "size": 2, + "mnemonic": "test", + "operands": "al, 0x40" + }, + { + "address": "0x14001443c", + "size": 2, + "mnemonic": "jne", + "operands": "0x140014448" + }, + { + "address": "0x14001443e", + "size": 3, + "mnemonic": "or", + "operands": "al, r13b" + }, + { + "address": "0x140014441", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rcx + r8*8 + 0x38], al" + }, + { + "address": "0x140014446", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001444e" + } + ], + "successors": [ + "0x14001444e" + ] + }, + { + "address": "0x1400142f9", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400142f9", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + 2]" + }, + { + "address": "0x1400142fd", + "size": 4, + "mnemonic": "cmp", + "operands": "dx, r11w" + }, + { + "address": "0x140014301", + "size": 2, + "mnemonic": "jne", + "operands": "0x140014317" + }, + { + "address": "0x140014303", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, r8" + }, + { + "address": "0x140014306", + "size": 2, + "mnemonic": "jae", + "operands": "0x140014337" + }, + { + "address": "0x140014308", + "size": 4, + "mnemonic": "cmp", + "operands": "word ptr [rcx], r9w" + }, + { + "address": "0x14001430c", + "size": 2, + "mnemonic": "jne", + "operands": "0x140014317" + }, + { + "address": "0x14001430e", + "size": 4, + "mnemonic": "add", + "operands": "rax, 4" + }, + { + "address": "0x140014312", + "size": 3, + "mnemonic": "mov", + "operands": "edx, r9d" + }, + { + "address": "0x140014315", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001431a" + } + ], + "successors": [ + "0x14001431a" + ] + }, + { + "address": "0x1400142cf", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400142cf", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rdx + r8*2]" + }, + { + "address": "0x1400142d3", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsi" + }, + { + "address": "0x1400142d6", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rsi" + }, + { + "address": "0x1400142d9", + "size": 3, + "mnemonic": "cmp", + "operands": "rsi, r8" + }, + { + "address": "0x1400142dc", + "size": 6, + "mnemonic": "jae", + "operands": "0x14001444e" + }, + { + "address": "0x1400142e2", + "size": 6, + "mnemonic": "mov", + "operands": "r11d, 0xd" + }, + { + "address": "0x1400142e8", + "size": 4, + "mnemonic": "lea", + "operands": "r13d, [r11 - 0xb]" + }, + { + "address": "0x1400142ec", + "size": 3, + "mnemonic": "movzx", + "operands": "edx, word ptr [rax]" + }, + { + "address": "0x1400142ef", + "size": 4, + "mnemonic": "cmp", + "operands": "dx, 0x1a" + }, + { + "address": "0x1400142f3", + "size": 6, + "mnemonic": "je", + "operands": "0x140014419" + } + ], + "successors": [ + "0x140014419", + "0x1400142f9" + ] + }, + { + "address": "0x14001444e", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001444e", + "size": 3, + "mnemonic": "sub", + "operands": "rbx, rsi" + }, + { + "address": "0x140014451", + "size": 3, + "mnemonic": "sar", + "operands": "rbx, 1" + }, + { + "address": "0x140014454", + "size": 3, + "mnemonic": "lea", + "operands": "eax, [rbx + rbx]" + }, + { + "address": "0x140014457", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x88]" + }, + { + "address": "0x14001445f", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140014463", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140014465", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140014467", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140014469", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14001446b", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001446c", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14001446d", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001446e", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001431a", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001431a", + "size": 3, + "mnemonic": "mov", + "operands": "word ptr [rbx], dx" + }, + { + "address": "0x14001431d", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r13" + }, + { + "address": "0x140014320", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140014323", + "size": 6, + "mnemonic": "mov", + "operands": "r9d, 0xa" + }, + { + "address": "0x140014329", + "size": 4, + "mnemonic": "lea", + "operands": "rbx, [rbx + r13]" + }, + { + "address": "0x14001432d", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, r8" + }, + { + "address": "0x140014330", + "size": 2, + "mnemonic": "jb", + "operands": "0x1400142ec" + } + ], + "successors": [ + "0x1400142ec", + "0x140014332" + ] + }, + { + "address": "0x1400142ec", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400142ec", + "size": 3, + "mnemonic": "movzx", + "operands": "edx, word ptr [rax]" + }, + { + "address": "0x1400142ef", + "size": 4, + "mnemonic": "cmp", + "operands": "dx, 0x1a" + }, + { + "address": "0x1400142f3", + "size": 6, + "mnemonic": "je", + "operands": "0x140014419" + } + ], + "successors": [ + "0x140014419", + "0x1400142f9" + ] + }, + { + "address": "0x140014332", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140014332", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14001444e" + } + ], + "successors": [ + "0x14001444e" + ] + } + ] + }, + { + "address": "0x140014475", + "name": "", + "blocks": [ + { + "address": "0x140014475", + "size": 21, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140014475", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140014476", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140014477", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140014478", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x14001447a", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x14001447c", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14001447e", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140014480", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x140014484", + "size": 3, + "mnemonic": "movsxd", + "operands": "rbp, ecx" + }, + { + "address": "0x140014487", + "size": 7, + "mnemonic": "lea", + "operands": "r11, [rip - 0x1448e]" + }, + { + "address": "0x14001448e", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rbp" + }, + { + "address": "0x140014491", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rbp" + }, + { + "address": "0x140014494", + "size": 4, + "mnemonic": "sar", + "operands": "r15, 6" + }, + { + "address": "0x140014498", + "size": 4, + "mnemonic": "and", + "operands": "r14d, 0x3f" + }, + { + "address": "0x14001449c", + "size": 3, + "mnemonic": "mov", + "operands": "r12, r9" + }, + { + "address": "0x14001449f", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x1400144a2", + "size": 8, + "mnemonic": "mov", + "operands": "rax, qword ptr [r11 + r15*8 + 0x33300]" + }, + { + "address": "0x1400144aa", + "size": 4, + "mnemonic": "lea", + "operands": "rsi, [r14 + r14*8]" + }, + { + "address": "0x1400144ae", + "size": 5, + "mnemonic": "mov", + "operands": "r10, qword ptr [rax + rsi*8 + 0x28]" + }, + { + "address": "0x1400144b3", + "size": 3, + "mnemonic": "test", + "operands": "r8, r8" + }, + { + "address": "0x1400144b6", + "size": 2, + "mnemonic": "je", + "operands": "0x1400144c4" + } + ], + "successors": [ + "0x1400144c4", + "0x1400144b8" + ] + }, + { + "address": "0x1400144c4", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400144c4", + "size": 5, + "mnemonic": "and", + "operands": "byte ptr [rax + rsi*8 + 0x38], 0xfb" + }, + { + "address": "0x1400144c9", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rdx + r8]" + }, + { + "address": "0x1400144cd", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdi" + }, + { + "address": "0x1400144d0", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdi" + }, + { + "address": "0x1400144d3", + "size": 6, + "mnemonic": "mov", + "operands": "r13d, 1" + }, + { + "address": "0x1400144d9", + "size": 3, + "mnemonic": "cmp", + "operands": "rdi, r9" + }, + { + "address": "0x1400144dc", + "size": 6, + "mnemonic": "jae", + "operands": "0x1400145dc" + }, + { + "address": "0x1400144e2", + "size": 2, + "mnemonic": "mov", + "operands": "cl, byte ptr [rax]" + }, + { + "address": "0x1400144e4", + "size": 3, + "mnemonic": "cmp", + "operands": "cl, 0x1a" + }, + { + "address": "0x1400144e7", + "size": 6, + "mnemonic": "je", + "operands": "0x1400145b9" + } + ], + "successors": [ + "0x1400145b9", + "0x1400144ed" + ] + }, + { + "address": "0x1400144b8", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400144b8", + "size": 3, + "mnemonic": "cmp", + "operands": "byte ptr [rdx], 0xa" + }, + { + "address": "0x1400144bb", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400144c4" + }, + { + "address": "0x1400144bd", + "size": 5, + "mnemonic": "or", + "operands": "byte ptr [rax + rsi*8 + 0x38], 4" + }, + { + "address": "0x1400144c2", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400144c9" + } + ], + "successors": [ + "0x1400144c9" + ] + }, + { + "address": "0x1400145b9", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400145b9", + "size": 8, + "mnemonic": "mov", + "operands": "r8, qword ptr [r11 + r15*8 + 0x33300]" + }, + { + "address": "0x1400145c1", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [r14 + r14*8]" + }, + { + "address": "0x1400145c5", + "size": 5, + "mnemonic": "mov", + "operands": "al, byte ptr [r8 + rdx*8 + 0x38]" + }, + { + "address": "0x1400145ca", + "size": 2, + "mnemonic": "test", + "operands": "al, 0x40" + }, + { + "address": "0x1400145cc", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400145d7" + }, + { + "address": "0x1400145ce", + "size": 2, + "mnemonic": "or", + "operands": "al, 2" + }, + { + "address": "0x1400145d0", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [r8 + rdx*8 + 0x38], al" + }, + { + "address": "0x1400145d5", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400145dc" + } + ], + "successors": [ + "0x1400145dc" + ] + }, + { + "address": "0x1400144ed", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400144ed", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rax + 1]" + }, + { + "address": "0x1400144f1", + "size": 3, + "mnemonic": "cmp", + "operands": "cl, 0xd" + }, + { + "address": "0x1400144f4", + "size": 2, + "mnemonic": "jne", + "operands": "0x140014509" + }, + { + "address": "0x1400144f6", + "size": 3, + "mnemonic": "cmp", + "operands": "rdx, r9" + }, + { + "address": "0x1400144f9", + "size": 2, + "mnemonic": "jae", + "operands": "0x14001451b" + }, + { + "address": "0x1400144fb", + "size": 3, + "mnemonic": "cmp", + "operands": "byte ptr [rdx], 0xa" + }, + { + "address": "0x1400144fe", + "size": 2, + "mnemonic": "jne", + "operands": "0x140014509" + }, + { + "address": "0x140014500", + "size": 4, + "mnemonic": "add", + "operands": "rax, 2" + }, + { + "address": "0x140014504", + "size": 3, + "mnemonic": "mov", + "operands": "byte ptr [rbx], 0xa" + }, + { + "address": "0x140014507", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001450e" + } + ], + "successors": [ + "0x14001450e" + ] + }, + { + "address": "0x1400144c9", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400144c9", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rdx + r8]" + }, + { + "address": "0x1400144cd", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdi" + }, + { + "address": "0x1400144d0", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdi" + }, + { + "address": "0x1400144d3", + "size": 6, + "mnemonic": "mov", + "operands": "r13d, 1" + }, + { + "address": "0x1400144d9", + "size": 3, + "mnemonic": "cmp", + "operands": "rdi, r9" + }, + { + "address": "0x1400144dc", + "size": 6, + "mnemonic": "jae", + "operands": "0x1400145dc" + }, + { + "address": "0x1400144e2", + "size": 2, + "mnemonic": "mov", + "operands": "cl, byte ptr [rax]" + }, + { + "address": "0x1400144e4", + "size": 3, + "mnemonic": "cmp", + "operands": "cl, 0x1a" + }, + { + "address": "0x1400144e7", + "size": 6, + "mnemonic": "je", + "operands": "0x1400145b9" + } + ], + "successors": [ + "0x1400145b9", + "0x1400144ed" + ] + }, + { + "address": "0x1400145dc", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400145dc", + "size": 2, + "mnemonic": "sub", + "operands": "ebx, edi" + }, + { + "address": "0x1400145de", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400145e7" + }, + { + "address": "0x1400145e0", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x1400145e2", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140014787" + } + ], + "successors": [ + "0x140014787" + ] + }, + { + "address": "0x14001450e", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001450e", + "size": 3, + "mnemonic": "inc", + "operands": "rbx" + }, + { + "address": "0x140014511", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, r9" + }, + { + "address": "0x140014514", + "size": 2, + "mnemonic": "jb", + "operands": "0x1400144e2" + } + ], + "successors": [ + "0x1400144e2", + "0x140014516" + ] + }, + { + "address": "0x140014787", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140014787", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x80]" + }, + { + "address": "0x14001478f", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140014793", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140014795", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140014797", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140014799", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14001479b", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001479c", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14001479d", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001479e", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400144e2", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400144e2", + "size": 2, + "mnemonic": "mov", + "operands": "cl, byte ptr [rax]" + }, + { + "address": "0x1400144e4", + "size": 3, + "mnemonic": "cmp", + "operands": "cl, 0x1a" + }, + { + "address": "0x1400144e7", + "size": 6, + "mnemonic": "je", + "operands": "0x1400145b9" + } + ], + "successors": [ + "0x1400145b9", + "0x1400144ed" + ] + }, + { + "address": "0x140014516", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140014516", + "size": 5, + "mnemonic": "jmp", + "operands": "0x1400145dc" + } + ], + "successors": [ + "0x1400145dc" + ] + } + ] + }, + { + "address": "0x1400148ca", + "name": "", + "blocks": [ + { + "address": "0x1400148ca", + "size": 19, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400148ca", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x1400148cb", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x1400148cc", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x1400148cd", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x1400148cf", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x1400148d1", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x1400148d3", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x1400148d5", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x1400148d9", + "size": 3, + "mnemonic": "movsxd", + "operands": "r13, ecx" + }, + { + "address": "0x1400148dc", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rdx" + }, + { + "address": "0x1400148df", + "size": 3, + "mnemonic": "mov", + "operands": "r12d, r8d" + }, + { + "address": "0x1400148e2", + "size": 4, + "mnemonic": "cmp", + "operands": "r13d, -2" + }, + { + "address": "0x1400148e6", + "size": 2, + "mnemonic": "jne", + "operands": "0x140014901" + }, + { + "address": "0x1400148e8", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d854" + }, + { + "address": "0x1400148ed", + "size": 2, + "mnemonic": "xor", + "operands": "esi, esi" + }, + { + "address": "0x1400148ef", + "size": 2, + "mnemonic": "mov", + "operands": "dword ptr [rax], esi" + }, + { + "address": "0x1400148f1", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x1400148f6", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 9" + }, + { + "address": "0x1400148fc", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140014d04" + } + ], + "successors": [ + "0x140014d04" + ] + }, + { + "address": "0x140014d04", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140014d04", + "size": 3, + "mnemonic": "or", + "operands": "eax, 0xffffffff" + }, + { + "address": "0x140014d07", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0xb0]" + }, + { + "address": "0x140014d0f", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x140014d13", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140014d15", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140014d17", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140014d19", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140014d1b", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140014d1c", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140014d1d", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140014d1e", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140014efa", + "name": "", + "blocks": [ + { + "address": "0x140014efa", + "size": 22, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140014efa", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140014efb", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x140014efe", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x140014f02", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rbp - 0x40], 0" + }, + { + "address": "0x140014f07", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x1e2e2], 0" + }, + { + "address": "0x140014f0e", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x30], 0" + }, + { + "address": "0x140014f12", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 0" + }, + { + "address": "0x140014f16", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x140014f1a", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x140014f1e", + "size": 2, + "mnemonic": "jne", + "operands": "0x140014f30" + }, + { + "address": "0x140014f20", + "size": 7, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rip + 0x1c501]" + }, + { + "address": "0x140014f27", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 1" + }, + { + "address": "0x140014f2b", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp - 0x28], xmm0" + }, + { + "address": "0x140014f30", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp - 0x40]" + }, + { + "address": "0x140014f34", + "size": 5, + "mnemonic": "call", + "operands": "0x140014d20" + }, + { + "address": "0x140014f39", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x18], 2" + }, + { + "address": "0x140014f3d", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rax" + }, + { + "address": "0x140014f40", + "size": 2, + "mnemonic": "jne", + "operands": "0x140014f4d" + }, + { + "address": "0x140014f42", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x40]" + }, + { + "address": "0x140014f46", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rcx + 0x3a8], 0xfffffffd" + }, + { + "address": "0x140014f4d", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x140014f51", + "size": 2, + "mnemonic": "je", + "operands": "0x140014f62" + } + ], + "successors": [ + "0x140014f62", + "0x140014f53" + ] + }, + { + "address": "0x140014f62", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140014f62", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x140014f66", + "size": 2, + "mnemonic": "je", + "operands": "0x140014f77" + } + ], + "successors": [ + "0x140014f77", + "0x140014f68" + ] + }, + { + "address": "0x140014f53", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140014f53", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0x14]" + }, + { + "address": "0x140014f56", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x140014f5a", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x140014f5f", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x20], ebx" + }, + { + "address": "0x140014f62", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x140014f66", + "size": 2, + "mnemonic": "je", + "operands": "0x140014f77" + } + ], + "successors": [ + "0x140014f77", + "0x140014f68" + ] + }, + { + "address": "0x140014f77", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140014f77", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140014f7c", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdi" + }, + { + "address": "0x140014f7f", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x78]" + }, + { + "address": "0x140014f84", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x140014f88", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140014f89", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140014f68", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140014f68", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0xc]" + }, + { + "address": "0x140014f6b", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x140014f6f", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x140014f74", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x24], ebx" + }, + { + "address": "0x140014f77", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140014f7c", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdi" + }, + { + "address": "0x140014f7f", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x78]" + }, + { + "address": "0x140014f84", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x140014f88", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140014f89", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140014f9e", + "name": "", + "blocks": [ + { + "address": "0x140014f9e", + "size": 22, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140014f9e", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140014f9f", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x140014fa2", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x140014fa6", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rbp - 0x40], 0" + }, + { + "address": "0x140014fab", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x1e23e], 0" + }, + { + "address": "0x140014fb2", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x30], 0" + }, + { + "address": "0x140014fb6", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 0" + }, + { + "address": "0x140014fba", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x140014fbe", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x140014fc2", + "size": 2, + "mnemonic": "jne", + "operands": "0x140014fd4" + }, + { + "address": "0x140014fc4", + "size": 7, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rip + 0x1c45d]" + }, + { + "address": "0x140014fcb", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 1" + }, + { + "address": "0x140014fcf", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp - 0x28], xmm0" + }, + { + "address": "0x140014fd4", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp - 0x40]" + }, + { + "address": "0x140014fd8", + "size": 5, + "mnemonic": "call", + "operands": "0x140014e40" + }, + { + "address": "0x140014fdd", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x18], 2" + }, + { + "address": "0x140014fe1", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rax" + }, + { + "address": "0x140014fe4", + "size": 2, + "mnemonic": "jne", + "operands": "0x140014ff1" + }, + { + "address": "0x140014fe6", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x40]" + }, + { + "address": "0x140014fea", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rcx + 0x3a8], 0xfffffffd" + }, + { + "address": "0x140014ff1", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x140014ff5", + "size": 2, + "mnemonic": "je", + "operands": "0x140015006" + } + ], + "successors": [ + "0x140015006", + "0x140014ff7" + ] + }, + { + "address": "0x140015006", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015006", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x14001500a", + "size": 2, + "mnemonic": "je", + "operands": "0x14001501b" + } + ], + "successors": [ + "0x14001501b", + "0x14001500c" + ] + }, + { + "address": "0x140014ff7", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140014ff7", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0x14]" + }, + { + "address": "0x140014ffa", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x140014ffe", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x140015003", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x20], ebx" + }, + { + "address": "0x140015006", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x14001500a", + "size": 2, + "mnemonic": "je", + "operands": "0x14001501b" + } + ], + "successors": [ + "0x14001501b", + "0x14001500c" + ] + }, + { + "address": "0x14001501b", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001501b", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140015020", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdi" + }, + { + "address": "0x140015023", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x78]" + }, + { + "address": "0x140015028", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x14001502c", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001502d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001500c", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001500c", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0xc]" + }, + { + "address": "0x14001500f", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x140015013", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x140015018", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x24], ebx" + }, + { + "address": "0x14001501b", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140015020", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdi" + }, + { + "address": "0x140015023", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x78]" + }, + { + "address": "0x140015028", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x14001502c", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001502d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140015582", + "name": "", + "blocks": [ + { + "address": "0x140015582", + "size": 25, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015582", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140015583", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x140015586", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x70" + }, + { + "address": "0x14001558a", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rbp - 0x40], 0" + }, + { + "address": "0x14001558f", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x1dc5a], 0" + }, + { + "address": "0x140015596", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x30], 0" + }, + { + "address": "0x14001559a", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 0" + }, + { + "address": "0x14001559e", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x1400155a2", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x1400155a6", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400155b8" + }, + { + "address": "0x1400155a8", + "size": 7, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rip + 0x1be79]" + }, + { + "address": "0x1400155af", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 1" + }, + { + "address": "0x1400155b3", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp - 0x28], xmm0" + }, + { + "address": "0x1400155b8", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp - 0x40]" + }, + { + "address": "0x1400155bc", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x1400155c1", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x30]" + }, + { + "address": "0x1400155c5", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x1400155ca", + "size": 5, + "mnemonic": "call", + "operands": "0x140015260" + }, + { + "address": "0x1400155cf", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x18], 2" + }, + { + "address": "0x1400155d3", + "size": 2, + "mnemonic": "mov", + "operands": "edi, eax" + }, + { + "address": "0x1400155d5", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400155e2" + }, + { + "address": "0x1400155d7", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x40]" + }, + { + "address": "0x1400155db", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rcx + 0x3a8], 0xfffffffd" + }, + { + "address": "0x1400155e2", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x1400155e6", + "size": 2, + "mnemonic": "je", + "operands": "0x1400155f7" + } + ], + "successors": [ + "0x1400155f7", + "0x1400155e8" + ] + }, + { + "address": "0x1400155f7", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400155f7", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x1400155fb", + "size": 2, + "mnemonic": "je", + "operands": "0x14001560c" + } + ], + "successors": [ + "0x14001560c", + "0x1400155fd" + ] + }, + { + "address": "0x1400155e8", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400155e8", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0x14]" + }, + { + "address": "0x1400155eb", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x1400155ef", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x1400155f4", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x20], ebx" + }, + { + "address": "0x1400155f7", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x1400155fb", + "size": 2, + "mnemonic": "je", + "operands": "0x14001560c" + } + ], + "successors": [ + "0x14001560c", + "0x1400155fd" + ] + }, + { + "address": "0x14001560c", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001560c", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x70]" + }, + { + "address": "0x140015611", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x140015613", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x10]" + }, + { + "address": "0x140015617", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x18]" + }, + { + "address": "0x14001561b", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x14001561e", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001561f", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400155fd", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400155fd", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0xc]" + }, + { + "address": "0x140015600", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x140015604", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x140015609", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x24], ebx" + }, + { + "address": "0x14001560c", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x70]" + }, + { + "address": "0x140015611", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x140015613", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x10]" + }, + { + "address": "0x140015617", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x18]" + }, + { + "address": "0x14001561b", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x14001561e", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001561f", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140015734", + "name": "", + "blocks": [ + { + "address": "0x140015734", + "size": 22, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015734", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140015736", + "size": 1, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140015737", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140015738", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140015739", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x14001573b", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x14001573d", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14001573f", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140015741", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x140015744", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x78" + }, + { + "address": "0x140015748", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x1b8f1]" + }, + { + "address": "0x14001574f", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x140015752", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x18], rax" + }, + { + "address": "0x140015756", + "size": 3, + "mnemonic": "xor", + "operands": "r12d, r12d" + }, + { + "address": "0x140015759", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x30], rdx" + }, + { + "address": "0x14001575d", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x38], r12d" + }, + { + "address": "0x140015761", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r9" + }, + { + "address": "0x140015764", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, r8" + }, + { + "address": "0x140015767", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rcx" + }, + { + "address": "0x14001576a", + "size": 3, + "mnemonic": "mov", + "operands": "edi, r12d" + }, + { + "address": "0x14001576d", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140015770", + "size": 2, + "mnemonic": "je", + "operands": "0x14001577e" + } + ], + "successors": [ + "0x14001577e", + "0x140015772" + ] + }, + { + "address": "0x14001577e", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001577e", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x140015781", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400157b0" + }, + { + "address": "0x140015783", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [r9 + 0x30], 1" + }, + { + "address": "0x140015788", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x14001578b", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [r9 + 0x2c], 0x16" + }, + { + "address": "0x140015793", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x140015795", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x140015798", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rbx" + }, + { + "address": "0x14001579d", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r12" + }, + { + "address": "0x1400157a2", + "size": 5, + "mnemonic": "call", + "operands": "0x14000aefc" + }, + { + "address": "0x1400157a7", + "size": 4, + "mnemonic": "or", + "operands": "rax, 0xffffffffffffffff" + }, + { + "address": "0x1400157ab", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140015a56" + } + ], + "successors": [ + "0x140015a56" + ] + }, + { + "address": "0x140015772", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015772", + "size": 3, + "mnemonic": "test", + "operands": "r8, r8" + }, + { + "address": "0x140015775", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001577e" + }, + { + "address": "0x140015777", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140015779", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140015a56" + } + ], + "successors": [ + "0x140015a56" + ] + }, + { + "address": "0x140015a56", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140015a56", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x18]" + }, + { + "address": "0x140015a5a", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x140015a5d", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140015a62", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x78" + }, + { + "address": "0x140015a66", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140015a68", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140015a6a", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140015a6c", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140015a6e", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140015a6f", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140015a70", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140015a71", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140015a72", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140015a7e", + "name": "", + "blocks": [ + { + "address": "0x140015a7e", + "size": 11, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015a7e", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140015a7f", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x140015a82", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x70" + }, + { + "address": "0x140015a86", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rbp - 0x40], 0" + }, + { + "address": "0x140015a8b", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x38]" + }, + { + "address": "0x140015a8f", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x30], 0" + }, + { + "address": "0x140015a93", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 0" + }, + { + "address": "0x140015a97", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x140015a9b", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x140015a9f", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140015aa2", + "size": 2, + "mnemonic": "je", + "operands": "0x140015aa9" + } + ], + "successors": [ + "0x140015aa9", + "0x140015aa4" + ] + }, + { + "address": "0x140015aa9", + "size": 17, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015aa9", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x1d740], 0" + }, + { + "address": "0x140015ab0", + "size": 2, + "mnemonic": "jne", + "operands": "0x140015ac2" + }, + { + "address": "0x140015ab2", + "size": 7, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rip + 0x1b96f]" + }, + { + "address": "0x140015ab9", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 1" + }, + { + "address": "0x140015abd", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp - 0x28], xmm0" + }, + { + "address": "0x140015ac2", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp - 0x40]" + }, + { + "address": "0x140015ac6", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x140015acb", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x30]" + }, + { + "address": "0x140015acf", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x140015ad4", + "size": 5, + "mnemonic": "call", + "operands": "0x140015620" + }, + { + "address": "0x140015ad9", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x18], 2" + }, + { + "address": "0x140015add", + "size": 2, + "mnemonic": "mov", + "operands": "edi, eax" + }, + { + "address": "0x140015adf", + "size": 2, + "mnemonic": "jne", + "operands": "0x140015aec" + }, + { + "address": "0x140015ae1", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x40]" + }, + { + "address": "0x140015ae5", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rcx + 0x3a8], 0xfffffffd" + }, + { + "address": "0x140015aec", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x140015af0", + "size": 2, + "mnemonic": "je", + "operands": "0x140015b01" + } + ], + "successors": [ + "0x140015b01", + "0x140015af2" + ] + }, + { + "address": "0x140015aa4", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015aa4", + "size": 3, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rax]" + }, + { + "address": "0x140015aa7", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140015ab9" + } + ], + "successors": [ + "0x140015ab9" + ] + }, + { + "address": "0x140015b01", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015b01", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x140015b05", + "size": 2, + "mnemonic": "je", + "operands": "0x140015b16" + } + ], + "successors": [ + "0x140015b16", + "0x140015b07" + ] + }, + { + "address": "0x140015af2", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015af2", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0x14]" + }, + { + "address": "0x140015af5", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x140015af9", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x140015afe", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x20], ebx" + }, + { + "address": "0x140015b01", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x140015b05", + "size": 2, + "mnemonic": "je", + "operands": "0x140015b16" + } + ], + "successors": [ + "0x140015b16", + "0x140015b07" + ] + }, + { + "address": "0x140015ab9", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015ab9", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 1" + }, + { + "address": "0x140015abd", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp - 0x28], xmm0" + }, + { + "address": "0x140015ac2", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp - 0x40]" + }, + { + "address": "0x140015ac6", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x140015acb", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x30]" + }, + { + "address": "0x140015acf", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x140015ad4", + "size": 5, + "mnemonic": "call", + "operands": "0x140015620" + }, + { + "address": "0x140015ad9", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x18], 2" + }, + { + "address": "0x140015add", + "size": 2, + "mnemonic": "mov", + "operands": "edi, eax" + }, + { + "address": "0x140015adf", + "size": 2, + "mnemonic": "jne", + "operands": "0x140015aec" + }, + { + "address": "0x140015ae1", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x40]" + }, + { + "address": "0x140015ae5", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rcx + 0x3a8], 0xfffffffd" + }, + { + "address": "0x140015aec", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x140015af0", + "size": 2, + "mnemonic": "je", + "operands": "0x140015b01" + } + ], + "successors": [ + "0x140015b01", + "0x140015af2" + ] + }, + { + "address": "0x140015b16", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140015b16", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x70]" + }, + { + "address": "0x140015b1b", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x140015b1d", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x10]" + }, + { + "address": "0x140015b21", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x18]" + }, + { + "address": "0x140015b25", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x140015b28", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140015b29", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140015b07", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140015b07", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rbp - 0xc]" + }, + { + "address": "0x140015b0a", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x40]" + }, + { + "address": "0x140015b0e", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x140015b13", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x24], ebx" + }, + { + "address": "0x140015b16", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x70]" + }, + { + "address": "0x140015b1b", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x140015b1d", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x10]" + }, + { + "address": "0x140015b21", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x18]" + }, + { + "address": "0x140015b25", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x140015b28", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140015b29", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140015c13", + "name": "", + "blocks": [ + { + "address": "0x140015c13", + "size": 15, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015c13", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140015c14", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x140015c17", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x80" + }, + { + "address": "0x140015c1e", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x1b41b]" + }, + { + "address": "0x140015c25", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x140015c28", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x10], rax" + }, + { + "address": "0x140015c2c", + "size": 2, + "mnemonic": "mov", + "operands": "esi, edx" + }, + { + "address": "0x140015c2e", + "size": 3, + "mnemonic": "movsxd", + "operands": "rdi, ecx" + }, + { + "address": "0x140015c31", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r8" + }, + { + "address": "0x140015c34", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x38]" + }, + { + "address": "0x140015c38", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d89c" + }, + { + "address": "0x140015c3d", + "size": 3, + "mnemonic": "lea", + "operands": "eax, [rdi + 1]" + }, + { + "address": "0x140015c40", + "size": 2, + "mnemonic": "xor", + "operands": "ebx, ebx" + }, + { + "address": "0x140015c42", + "size": 5, + "mnemonic": "cmp", + "operands": "eax, 0x100" + }, + { + "address": "0x140015c47", + "size": 2, + "mnemonic": "ja", + "operands": "0x140015c56" + } + ], + "successors": [ + "0x140015c56", + "0x140015c49" + ] + }, + { + "address": "0x140015c56", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015c56", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rbp - 0x30]" + }, + { + "address": "0x140015c5a", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x140015c5c", + "size": 3, + "mnemonic": "sar", + "operands": "eax, 8" + }, + { + "address": "0x140015c5f", + "size": 6, + "mnemonic": "mov", + "operands": "r10d, 1" + }, + { + "address": "0x140015c65", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, al" + }, + { + "address": "0x140015c68", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdx]" + }, + { + "address": "0x140015c6b", + "size": 4, + "mnemonic": "cmp", + "operands": "word ptr [rax + rcx*2], bx" + }, + { + "address": "0x140015c6f", + "size": 2, + "mnemonic": "jge", + "operands": "0x140015c81" + }, + { + "address": "0x140015c71", + "size": 3, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x40], cl" + }, + { + "address": "0x140015c74", + "size": 4, + "mnemonic": "lea", + "operands": "r9d, [r10 + 1]" + }, + { + "address": "0x140015c78", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x3f], dil" + }, + { + "address": "0x140015c7c", + "size": 3, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x3e], bl" + }, + { + "address": "0x140015c7f", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140015c8b" + } + ], + "successors": [ + "0x140015c8b" + ] + }, + { + "address": "0x140015c49", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015c49", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp - 0x30]" + }, + { + "address": "0x140015c4d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax]" + }, + { + "address": "0x140015c50", + "size": 4, + "mnemonic": "movzx", + "operands": "eax, word ptr [rcx + rdi*2]" + }, + { + "address": "0x140015c54", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140015cd5" + } + ], + "successors": [ + "0x140015cd5" + ] + }, + { + "address": "0x140015c8b", + "size": 16, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015c8b", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140015c8d", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x30], r10d" + }, + { + "address": "0x140015c92", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x18], eax" + }, + { + "address": "0x140015c95", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbp - 0x40]" + }, + { + "address": "0x140015c99", + "size": 4, + "mnemonic": "mov", + "operands": "word ptr [rbp - 0x14], ax" + }, + { + "address": "0x140015c9d", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x30]" + }, + { + "address": "0x140015ca1", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx + 0xc]" + }, + { + "address": "0x140015ca4", + "size": 3, + "mnemonic": "mov", + "operands": "edx, r10d" + }, + { + "address": "0x140015ca7", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], eax" + }, + { + "address": "0x140015cab", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp - 0x18]" + }, + { + "address": "0x140015caf", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x140015cb4", + "size": 5, + "mnemonic": "call", + "operands": "0x140016050" + }, + { + "address": "0x140015cb9", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140015cbb", + "size": 2, + "mnemonic": "jne", + "operands": "0x140015cd1" + }, + { + "address": "0x140015cbd", + "size": 3, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x20], bl" + }, + { + "address": "0x140015cc0", + "size": 2, + "mnemonic": "je", + "operands": "0x140015ccd" + } + ], + "successors": [ + "0x140015ccd", + "0x140015cc2" + ] + }, + { + "address": "0x140015cd5", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015cd5", + "size": 2, + "mnemonic": "and", + "operands": "eax, esi" + }, + { + "address": "0x140015cd7", + "size": 3, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x20], bl" + }, + { + "address": "0x140015cda", + "size": 2, + "mnemonic": "je", + "operands": "0x140015ce7" + } + ], + "successors": [ + "0x140015ce7", + "0x140015cdc" + ] + }, + { + "address": "0x140015ccd", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015ccd", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140015ccf", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140015ce7" + } + ], + "successors": [ + "0x140015ce7" + ] + }, + { + "address": "0x140015cc2", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015cc2", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp - 0x38]" + }, + { + "address": "0x140015cc6", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rax + 0x3a8], 0xfffffffd" + }, + { + "address": "0x140015ccd", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140015ccf", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140015ce7" + } + ], + "successors": [ + "0x140015ce7" + ] + }, + { + "address": "0x140015ce7", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140015ce7", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x10]" + }, + { + "address": "0x140015ceb", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x140015cee", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140015cf3", + "size": 8, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x80]" + }, + { + "address": "0x140015cfb", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x10]" + }, + { + "address": "0x140015cff", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x18]" + }, + { + "address": "0x140015d03", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x20]" + }, + { + "address": "0x140015d07", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x140015d0a", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140015d0b", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140015cdc", + "size": 12, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140015cdc", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x38]" + }, + { + "address": "0x140015ce0", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rcx + 0x3a8], 0xfffffffd" + }, + { + "address": "0x140015ce7", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x10]" + }, + { + "address": "0x140015ceb", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x140015cee", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140015cf3", + "size": 8, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x80]" + }, + { + "address": "0x140015cfb", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x10]" + }, + { + "address": "0x140015cff", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x18]" + }, + { + "address": "0x140015d03", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x20]" + }, + { + "address": "0x140015d07", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x140015d0a", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140015d0b", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140015d0c", + "name": "", + "blocks": [ + { + "address": "0x140015d0c", + "size": 30, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015d0c", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140015d0e", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140015d10", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140015d12", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x70" + }, + { + "address": "0x140015d16", + "size": 5, + "mnemonic": "lea", + "operands": "rbp, [rsp + 0x40]" + }, + { + "address": "0x140015d1b", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x50], rbx" + }, + { + "address": "0x140015d1f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x58], rsi" + }, + { + "address": "0x140015d23", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x60], rdi" + }, + { + "address": "0x140015d27", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x68], r12" + }, + { + "address": "0x140015d2b", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x1b30e]" + }, + { + "address": "0x140015d32", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rbp" + }, + { + "address": "0x140015d35", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x28], rax" + }, + { + "address": "0x140015d39", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rdx" + }, + { + "address": "0x140015d3c", + "size": 3, + "mnemonic": "mov", + "operands": "r15, r9" + }, + { + "address": "0x140015d3f", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rcx" + }, + { + "address": "0x140015d42", + "size": 3, + "mnemonic": "mov", + "operands": "esi, r8d" + }, + { + "address": "0x140015d45", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 8]" + }, + { + "address": "0x140015d49", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d89c" + }, + { + "address": "0x140015d4e", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x10]" + }, + { + "address": "0x140015d52", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x140015d55", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x140015d58", + "size": 2, + "mnemonic": "mov", + "operands": "edx, esi" + }, + { + "address": "0x140015d5a", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r14" + }, + { + "address": "0x140015d5d", + "size": 4, + "mnemonic": "mov", + "operands": "r12d, dword ptr [rax + 0xc]" + }, + { + "address": "0x140015d61", + "size": 5, + "mnemonic": "call", + "operands": "0x140011ff0" + }, + { + "address": "0x140015d66", + "size": 3, + "mnemonic": "movsxd", + "operands": "rdi, eax" + }, + { + "address": "0x140015d69", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140015d6b", + "size": 2, + "mnemonic": "jne", + "operands": "0x140015d74" + }, + { + "address": "0x140015d6d", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x140015d6f", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140015e4e" + } + ], + "successors": [ + "0x140015e4e" + ] + }, + { + "address": "0x140015e4e", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015e4e", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp + 0x20], 0" + }, + { + "address": "0x140015e52", + "size": 2, + "mnemonic": "je", + "operands": "0x140015e5f" + } + ], + "successors": [ + "0x140015e5f", + "0x140015e54" + ] + }, + { + "address": "0x140015e5f", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140015e5f", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x140015e61", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x28]" + }, + { + "address": "0x140015e65", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rbp" + }, + { + "address": "0x140015e68", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140015e6d", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rbp + 0x50]" + }, + { + "address": "0x140015e71", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rbp + 0x58]" + }, + { + "address": "0x140015e75", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rbp + 0x60]" + }, + { + "address": "0x140015e79", + "size": 4, + "mnemonic": "mov", + "operands": "r12, qword ptr [rbp + 0x68]" + }, + { + "address": "0x140015e7d", + "size": 4, + "mnemonic": "lea", + "operands": "rsp, [rbp + 0x30]" + }, + { + "address": "0x140015e81", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140015e83", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140015e85", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140015e86", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140015e54", + "size": 15, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140015e54", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 8]" + }, + { + "address": "0x140015e58", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rax + 0x3a8], 0xfffffffd" + }, + { + "address": "0x140015e5f", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x140015e61", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x28]" + }, + { + "address": "0x140015e65", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rbp" + }, + { + "address": "0x140015e68", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140015e6d", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rbp + 0x50]" + }, + { + "address": "0x140015e71", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rbp + 0x58]" + }, + { + "address": "0x140015e75", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rbp + 0x60]" + }, + { + "address": "0x140015e79", + "size": 4, + "mnemonic": "mov", + "operands": "r12, qword ptr [rbp + 0x68]" + }, + { + "address": "0x140015e7d", + "size": 4, + "mnemonic": "lea", + "operands": "rsp, [rbp + 0x30]" + }, + { + "address": "0x140015e81", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140015e83", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140015e85", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140015e86", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140015e8a", + "name": "", + "blocks": [ + { + "address": "0x140015e8a", + "size": 26, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015e8a", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140015e8b", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140015e8c", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140015e8d", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140015e8f", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140015e91", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140015e93", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0xd0" + }, + { + "address": "0x140015e9a", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x1b19f]" + }, + { + "address": "0x140015ea1", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x140015ea4", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0xc0], rax" + }, + { + "address": "0x140015eac", + "size": 8, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x130]" + }, + { + "address": "0x140015eb4", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x140015eb6", + "size": 3, + "mnemonic": "mov", + "operands": "ebp, r9d" + }, + { + "address": "0x140015eb9", + "size": 3, + "mnemonic": "mov", + "operands": "r14, r8" + }, + { + "address": "0x140015ebc", + "size": 3, + "mnemonic": "mov", + "operands": "r12, rcx" + }, + { + "address": "0x140015ebf", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rsi], rdi" + }, + { + "address": "0x140015ec2", + "size": 3, + "mnemonic": "cmp", + "operands": "edx, 1" + }, + { + "address": "0x140015ec5", + "size": 6, + "mnemonic": "jne", + "operands": "0x140015fa5" + }, + { + "address": "0x140015ecb", + "size": 5, + "mnemonic": "lea", + "operands": "r9, [rsp + 0x40]" + }, + { + "address": "0x140015ed0", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x20], 0x80" + }, + { + "address": "0x140015ed8", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, ebp" + }, + { + "address": "0x140015edb", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r14" + }, + { + "address": "0x140015ede", + "size": 5, + "mnemonic": "call", + "operands": "0x140015d0c" + }, + { + "address": "0x140015ee3", + "size": 3, + "mnemonic": "movsxd", + "operands": "rbx, eax" + }, + { + "address": "0x140015ee6", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140015ee8", + "size": 2, + "mnemonic": "je", + "operands": "0x140015f2d" + } + ], + "successors": [ + "0x140015f2d", + "0x140015eea" + ] + }, + { + "address": "0x140015f2d", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015f2d", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xa1c5]" + }, + { + "address": "0x140015f33", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 0x7a" + }, + { + "address": "0x140015f36", + "size": 6, + "mnemonic": "jne", + "operands": "0x140016016" + }, + { + "address": "0x140015f3c", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x140015f3f", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x20], edi" + }, + { + "address": "0x140015f43", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, ebp" + }, + { + "address": "0x140015f46", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r14" + }, + { + "address": "0x140015f49", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r12" + }, + { + "address": "0x140015f4c", + "size": 5, + "mnemonic": "call", + "operands": "0x140015d0c" + }, + { + "address": "0x140015f51", + "size": 3, + "mnemonic": "movsxd", + "operands": "r15, eax" + }, + { + "address": "0x140015f54", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140015f56", + "size": 6, + "mnemonic": "je", + "operands": "0x140016016" + } + ], + "successors": [ + "0x140016016", + "0x140015f5c" + ] + }, + { + "address": "0x140015eea", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015eea", + "size": 3, + "mnemonic": "lea", + "operands": "edx, [rdi + 1]" + }, + { + "address": "0x140015eed", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140015ef0", + "size": 5, + "mnemonic": "call", + "operands": "0x140011a80" + }, + { + "address": "0x140015ef5", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x140015ef7", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rsi], rax" + }, + { + "address": "0x140015efa", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140015eff", + "size": 3, + "mnemonic": "cmp", + "operands": "qword ptr [rsi], rdi" + }, + { + "address": "0x140015f02", + "size": 6, + "mnemonic": "je", + "operands": "0x140016016" + } + ], + "successors": [ + "0x140016016", + "0x140015f08" + ] + }, + { + "address": "0x140016016", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140016016", + "size": 3, + "mnemonic": "or", + "operands": "eax, 0xffffffff" + }, + { + "address": "0x140016019", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0xc0]" + }, + { + "address": "0x140016021", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x140016024", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140016029", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0xd0" + }, + { + "address": "0x140016030", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140016032", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140016034", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140016036", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140016037", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140016038", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140016039", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001603a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140015f5c", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015f5c", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r15" + }, + { + "address": "0x140015f5f", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 1" + }, + { + "address": "0x140015f64", + "size": 5, + "mnemonic": "call", + "operands": "0x140011a80" + }, + { + "address": "0x140015f69", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x140015f6c", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140015f6f", + "size": 2, + "mnemonic": "je", + "operands": "0x140015f96" + } + ], + "successors": [ + "0x140015f96", + "0x140015f71" + ] + }, + { + "address": "0x140015f08", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015f08", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsi]" + }, + { + "address": "0x140015f0b", + "size": 3, + "mnemonic": "lea", + "operands": "eax, [rbx - 1]" + }, + { + "address": "0x140015f0e", + "size": 3, + "mnemonic": "movsxd", + "operands": "r9, eax" + }, + { + "address": "0x140015f11", + "size": 5, + "mnemonic": "lea", + "operands": "r8, [rsp + 0x40]" + }, + { + "address": "0x140015f16", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x140015f19", + "size": 5, + "mnemonic": "call", + "operands": "0x14001c3c0" + }, + { + "address": "0x140015f1e", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140015f20", + "size": 6, + "mnemonic": "jne", + "operands": "0x14001603b" + }, + { + "address": "0x140015f26", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140015f28", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140016019" + } + ], + "successors": [ + "0x140016019" + ] + }, + { + "address": "0x140015f96", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015f96", + "size": 3, + "mnemonic": "or", + "operands": "edi, 0xffffffff" + }, + { + "address": "0x140015f99", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140015f9c", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140015fa1", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x140015fa3", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140016019" + } + ], + "successors": [ + "0x140016019" + ] + }, + { + "address": "0x140015f71", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015f71", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rax" + }, + { + "address": "0x140015f74", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x20], r15d" + }, + { + "address": "0x140015f79", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, ebp" + }, + { + "address": "0x140015f7c", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r14" + }, + { + "address": "0x140015f7f", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r12" + }, + { + "address": "0x140015f82", + "size": 5, + "mnemonic": "call", + "operands": "0x140015d0c" + }, + { + "address": "0x140015f87", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140015f89", + "size": 2, + "mnemonic": "je", + "operands": "0x140015f96" + } + ], + "successors": [ + "0x140015f96", + "0x140015f8b" + ] + }, + { + "address": "0x140016019", + "size": 12, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140016019", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0xc0]" + }, + { + "address": "0x140016021", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x140016024", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140016029", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0xd0" + }, + { + "address": "0x140016030", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140016032", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140016034", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140016036", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140016037", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140016038", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140016039", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001603a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140015f8b", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015f8b", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140015f8e", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdi" + }, + { + "address": "0x140015f91", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rsi], rax" + }, + { + "address": "0x140015f94", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140015f99" + } + ], + "successors": [ + "0x140015f99" + ] + }, + { + "address": "0x140015f99", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015f99", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140015f9c", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140015fa1", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x140015fa3", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140016019" + } + ], + "successors": [ + "0x140016019" + ] + } + ] + }, + { + "address": "0x140016050", + "name": "", + "blocks": [ + { + "address": "0x140016050", + "size": 39, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016050", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140016052", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140016054", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140016056", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140016058", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14001605a", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x14001605e", + "size": 5, + "mnemonic": "lea", + "operands": "rbp, [rsp + 0x30]" + }, + { + "address": "0x140016063", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x60], rbx" + }, + { + "address": "0x140016067", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x68], rsi" + }, + { + "address": "0x14001606b", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x70], rdi" + }, + { + "address": "0x14001606f", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x1afca]" + }, + { + "address": "0x140016076", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rbp" + }, + { + "address": "0x140016079", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x28], rax" + }, + { + "address": "0x14001607d", + "size": 3, + "mnemonic": "mov", + "operands": "r13d, edx" + }, + { + "address": "0x140016080", + "size": 3, + "mnemonic": "mov", + "operands": "r15d, r9d" + }, + { + "address": "0x140016083", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rcx" + }, + { + "address": "0x140016086", + "size": 3, + "mnemonic": "mov", + "operands": "r12, r8" + }, + { + "address": "0x140016089", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 8]" + }, + { + "address": "0x14001608d", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d89c" + }, + { + "address": "0x140016092", + "size": 6, + "mnemonic": "mov", + "operands": "edi, dword ptr [rbp + 0x88]" + }, + { + "address": "0x140016098", + "size": 2, + "mnemonic": "test", + "operands": "edi, edi" + }, + { + "address": "0x14001609a", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400160a3" + }, + { + "address": "0x14001609c", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x10]" + }, + { + "address": "0x1400160a0", + "size": 3, + "mnemonic": "mov", + "operands": "edi, dword ptr [rax + 0xc]" + }, + { + "address": "0x1400160a3", + "size": 6, + "mnemonic": "neg", + "operands": "dword ptr [rbp + 0x90]" + }, + { + "address": "0x1400160a9", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, r15d" + }, + { + "address": "0x1400160ac", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r12" + }, + { + "address": "0x1400160af", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, edi" + }, + { + "address": "0x1400160b1", + "size": 2, + "mnemonic": "sbb", + "operands": "edx, edx" + }, + { + "address": "0x1400160b3", + "size": 5, + "mnemonic": "and", + "operands": "dword ptr [rsp + 0x28], 0" + }, + { + "address": "0x1400160b8", + "size": 6, + "mnemonic": "and", + "operands": "qword ptr [rsp + 0x20], 0" + }, + { + "address": "0x1400160be", + "size": 3, + "mnemonic": "and", + "operands": "edx, 8" + }, + { + "address": "0x1400160c1", + "size": 2, + "mnemonic": "inc", + "operands": "edx" + }, + { + "address": "0x1400160c3", + "size": 5, + "mnemonic": "call", + "operands": "0x14001702c" + }, + { + "address": "0x1400160c8", + "size": 3, + "mnemonic": "movsxd", + "operands": "r14, eax" + }, + { + "address": "0x1400160cb", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x1400160cd", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400160d6" + }, + { + "address": "0x1400160cf", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x1400160d1", + "size": 5, + "mnemonic": "jmp", + "operands": "0x1400161a6" + } + ], + "successors": [ + "0x1400161a6" + ] + }, + { + "address": "0x1400161a6", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400161a6", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp + 0x20], 0" + }, + { + "address": "0x1400161aa", + "size": 2, + "mnemonic": "je", + "operands": "0x1400161b7" + } + ], + "successors": [ + "0x1400161b7", + "0x1400161ac" + ] + }, + { + "address": "0x1400161b7", + "size": 14, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400161b7", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x1400161b9", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x28]" + }, + { + "address": "0x1400161bd", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rbp" + }, + { + "address": "0x1400161c0", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x1400161c5", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rbp + 0x60]" + }, + { + "address": "0x1400161c9", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rbp + 0x68]" + }, + { + "address": "0x1400161cd", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rbp + 0x70]" + }, + { + "address": "0x1400161d1", + "size": 4, + "mnemonic": "lea", + "operands": "rsp, [rbp + 0x30]" + }, + { + "address": "0x1400161d5", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x1400161d7", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x1400161d9", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x1400161db", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x1400161dd", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x1400161de", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400161ac", + "size": 16, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400161ac", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 8]" + }, + { + "address": "0x1400161b0", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rax + 0x3a8], 0xfffffffd" + }, + { + "address": "0x1400161b7", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x1400161b9", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x28]" + }, + { + "address": "0x1400161bd", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rbp" + }, + { + "address": "0x1400161c0", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x1400161c5", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rbp + 0x60]" + }, + { + "address": "0x1400161c9", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rbp + 0x68]" + }, + { + "address": "0x1400161cd", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rbp + 0x70]" + }, + { + "address": "0x1400161d1", + "size": 4, + "mnemonic": "lea", + "operands": "rsp, [rbp + 0x30]" + }, + { + "address": "0x1400161d5", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x1400161d7", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x1400161d9", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x1400161db", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x1400161dd", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x1400161de", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400161e0", + "name": "", + "blocks": [ + { + "address": "0x1400161e0", + "size": 26, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400161e0", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x1400161e2", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x1400161e4", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x1400161e6", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x1400161e8", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x1400161ea", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x1400161ee", + "size": 5, + "mnemonic": "lea", + "operands": "rbp, [rsp + 0x50]" + }, + { + "address": "0x1400161f3", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x40], rbx" + }, + { + "address": "0x1400161f7", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x48], rsi" + }, + { + "address": "0x1400161fb", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x50], rdi" + }, + { + "address": "0x1400161ff", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x1ae3a]" + }, + { + "address": "0x140016206", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rbp" + }, + { + "address": "0x140016209", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 8], rax" + }, + { + "address": "0x14001620d", + "size": 4, + "mnemonic": "movsxd", + "operands": "rdi, dword ptr [rbp + 0x60]" + }, + { + "address": "0x140016211", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, r9" + }, + { + "address": "0x140016214", + "size": 3, + "mnemonic": "mov", + "operands": "r12d, r8d" + }, + { + "address": "0x140016217", + "size": 3, + "mnemonic": "mov", + "operands": "r13, rdx" + }, + { + "address": "0x14001621a", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14001621d", + "size": 2, + "mnemonic": "test", + "operands": "edi, edi" + }, + { + "address": "0x14001621f", + "size": 2, + "mnemonic": "jle", + "operands": "0x140016235" + }, + { + "address": "0x140016221", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rdi" + }, + { + "address": "0x140016224", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r9" + }, + { + "address": "0x140016227", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d9c0" + }, + { + "address": "0x14001622c", + "size": 2, + "mnemonic": "cmp", + "operands": "eax, edi" + }, + { + "address": "0x14001622e", + "size": 3, + "mnemonic": "lea", + "operands": "edi, [rax + 1]" + }, + { + "address": "0x140016231", + "size": 2, + "mnemonic": "jl", + "operands": "0x140016235" + } + ], + "successors": [ + "0x140016235", + "0x140016233" + ] + }, + { + "address": "0x140016235", + "size": 19, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016235", + "size": 4, + "mnemonic": "mov", + "operands": "r14d, dword ptr [rbp + 0x78]" + }, + { + "address": "0x140016239", + "size": 3, + "mnemonic": "test", + "operands": "r14d, r14d" + }, + { + "address": "0x14001623c", + "size": 2, + "mnemonic": "jne", + "operands": "0x140016245" + }, + { + "address": "0x14001623e", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx]" + }, + { + "address": "0x140016241", + "size": 4, + "mnemonic": "mov", + "operands": "r14d, dword ptr [rax + 0xc]" + }, + { + "address": "0x140016245", + "size": 6, + "mnemonic": "neg", + "operands": "dword ptr [rbp + 0x80]" + }, + { + "address": "0x14001624b", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, edi" + }, + { + "address": "0x14001624e", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rsi" + }, + { + "address": "0x140016251", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, r14d" + }, + { + "address": "0x140016254", + "size": 2, + "mnemonic": "sbb", + "operands": "edx, edx" + }, + { + "address": "0x140016256", + "size": 5, + "mnemonic": "and", + "operands": "dword ptr [rsp + 0x28], 0" + }, + { + "address": "0x14001625b", + "size": 6, + "mnemonic": "and", + "operands": "qword ptr [rsp + 0x20], 0" + }, + { + "address": "0x140016261", + "size": 3, + "mnemonic": "and", + "operands": "edx, 8" + }, + { + "address": "0x140016264", + "size": 2, + "mnemonic": "inc", + "operands": "edx" + }, + { + "address": "0x140016266", + "size": 5, + "mnemonic": "call", + "operands": "0x14001702c" + }, + { + "address": "0x14001626b", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14001626d", + "size": 3, + "mnemonic": "movsxd", + "operands": "r15, eax" + }, + { + "address": "0x140016270", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140016272", + "size": 6, + "mnemonic": "je", + "operands": "0x1400164eb" + } + ], + "successors": [ + "0x1400164eb", + "0x140016278" + ] + }, + { + "address": "0x140016233", + "size": 20, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016233", + "size": 2, + "mnemonic": "mov", + "operands": "edi, eax" + }, + { + "address": "0x140016235", + "size": 4, + "mnemonic": "mov", + "operands": "r14d, dword ptr [rbp + 0x78]" + }, + { + "address": "0x140016239", + "size": 3, + "mnemonic": "test", + "operands": "r14d, r14d" + }, + { + "address": "0x14001623c", + "size": 2, + "mnemonic": "jne", + "operands": "0x140016245" + }, + { + "address": "0x14001623e", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx]" + }, + { + "address": "0x140016241", + "size": 4, + "mnemonic": "mov", + "operands": "r14d, dword ptr [rax + 0xc]" + }, + { + "address": "0x140016245", + "size": 6, + "mnemonic": "neg", + "operands": "dword ptr [rbp + 0x80]" + }, + { + "address": "0x14001624b", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, edi" + }, + { + "address": "0x14001624e", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rsi" + }, + { + "address": "0x140016251", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, r14d" + }, + { + "address": "0x140016254", + "size": 2, + "mnemonic": "sbb", + "operands": "edx, edx" + }, + { + "address": "0x140016256", + "size": 5, + "mnemonic": "and", + "operands": "dword ptr [rsp + 0x28], 0" + }, + { + "address": "0x14001625b", + "size": 6, + "mnemonic": "and", + "operands": "qword ptr [rsp + 0x20], 0" + }, + { + "address": "0x140016261", + "size": 3, + "mnemonic": "and", + "operands": "edx, 8" + }, + { + "address": "0x140016264", + "size": 2, + "mnemonic": "inc", + "operands": "edx" + }, + { + "address": "0x140016266", + "size": 5, + "mnemonic": "call", + "operands": "0x14001702c" + }, + { + "address": "0x14001626b", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14001626d", + "size": 3, + "mnemonic": "movsxd", + "operands": "r15, eax" + }, + { + "address": "0x140016270", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140016272", + "size": 6, + "mnemonic": "je", + "operands": "0x1400164eb" + } + ], + "successors": [ + "0x1400164eb", + "0x140016278" + ] + }, + { + "address": "0x1400164eb", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400164eb", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 8]" + }, + { + "address": "0x1400164ef", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rbp" + }, + { + "address": "0x1400164f2", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x1400164f7", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rbp + 0x40]" + }, + { + "address": "0x1400164fb", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rbp + 0x48]" + }, + { + "address": "0x1400164ff", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rbp + 0x50]" + }, + { + "address": "0x140016503", + "size": 4, + "mnemonic": "lea", + "operands": "rsp, [rbp + 0x10]" + }, + { + "address": "0x140016507", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140016509", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001650b", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14001650d", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14001650f", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140016510", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140016278", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016278", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r15" + }, + { + "address": "0x14001627b", + "size": 3, + "mnemonic": "add", + "operands": "rax, rax" + }, + { + "address": "0x14001627e", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + 0x10]" + }, + { + "address": "0x140016282", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, rcx" + }, + { + "address": "0x140016285", + "size": 3, + "mnemonic": "sbb", + "operands": "rax, rax" + }, + { + "address": "0x140016288", + "size": 3, + "mnemonic": "and", + "operands": "rax, rcx" + }, + { + "address": "0x14001628b", + "size": 6, + "mnemonic": "je", + "operands": "0x1400164ce" + } + ], + "successors": [ + "0x1400164ce", + "0x140016291" + ] + }, + { + "address": "0x1400164ce", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400164ce", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdx" + }, + { + "address": "0x1400164d1", + "size": 2, + "mnemonic": "mov", + "operands": "esi, edx" + }, + { + "address": "0x1400164d3", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x1400164d6", + "size": 2, + "mnemonic": "je", + "operands": "0x1400164e9" + } + ], + "successors": [ + "0x1400164e9", + "0x1400164d8" + ] + }, + { + "address": "0x140016291", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016291", + "size": 10, + "mnemonic": "movabs", + "operands": "r8, 0xffffffffffffff0" + }, + { + "address": "0x14001629b", + "size": 6, + "mnemonic": "cmp", + "operands": "rax, 0x400" + }, + { + "address": "0x1400162a1", + "size": 2, + "mnemonic": "ja", + "operands": "0x1400162d4" + } + ], + "successors": [ + "0x1400162d4", + "0x1400162a3" + ] + }, + { + "address": "0x1400164e9", + "size": 14, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400164e9", + "size": 2, + "mnemonic": "mov", + "operands": "eax, esi" + }, + { + "address": "0x1400164eb", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 8]" + }, + { + "address": "0x1400164ef", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rbp" + }, + { + "address": "0x1400164f2", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x1400164f7", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rbp + 0x40]" + }, + { + "address": "0x1400164fb", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rbp + 0x48]" + }, + { + "address": "0x1400164ff", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rbp + 0x50]" + }, + { + "address": "0x140016503", + "size": 4, + "mnemonic": "lea", + "operands": "rsp, [rbp + 0x10]" + }, + { + "address": "0x140016507", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140016509", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001650b", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14001650d", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14001650f", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140016510", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400164d8", + "size": 18, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400164d8", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbx - 0x10]" + }, + { + "address": "0x1400164dc", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rcx], 0xdddd" + }, + { + "address": "0x1400164e2", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400164e9" + }, + { + "address": "0x1400164e4", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x1400164e9", + "size": 2, + "mnemonic": "mov", + "operands": "eax, esi" + }, + { + "address": "0x1400164eb", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 8]" + }, + { + "address": "0x1400164ef", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rbp" + }, + { + "address": "0x1400164f2", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x1400164f7", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rbp + 0x40]" + }, + { + "address": "0x1400164fb", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rbp + 0x48]" + }, + { + "address": "0x1400164ff", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rbp + 0x50]" + }, + { + "address": "0x140016503", + "size": 4, + "mnemonic": "lea", + "operands": "rsp, [rbp + 0x10]" + }, + { + "address": "0x140016507", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140016509", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001650b", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14001650d", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14001650f", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140016510", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400162d4", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400162d4", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x1400162d7", + "size": 5, + "mnemonic": "call", + "operands": "0x140015200" + }, + { + "address": "0x1400162dc", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x1400162de", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x1400162e1", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x1400162e4", + "size": 2, + "mnemonic": "je", + "operands": "0x1400162f0" + } + ], + "successors": [ + "0x1400162f0", + "0x1400162e6" + ] + }, + { + "address": "0x1400162a3", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400162a3", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + 0xf]" + }, + { + "address": "0x1400162a7", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, rax" + }, + { + "address": "0x1400162aa", + "size": 2, + "mnemonic": "ja", + "operands": "0x1400162af" + } + ], + "successors": [ + "0x1400162af", + "0x1400162ac" + ] + }, + { + "address": "0x1400162f0", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400162f0", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x1400162f3", + "size": 6, + "mnemonic": "je", + "operands": "0x1400164d1" + } + ], + "successors": [ + "0x1400164d1", + "0x1400162f9" + ] + }, + { + "address": "0x1400162e6", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400162e6", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0xdddd" + }, + { + "address": "0x1400162ec", + "size": 4, + "mnemonic": "add", + "operands": "rbx, 0x10" + }, + { + "address": "0x1400162f0", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x1400162f3", + "size": 6, + "mnemonic": "je", + "operands": "0x1400164d1" + } + ], + "successors": [ + "0x1400164d1", + "0x1400162f9" + ] + }, + { + "address": "0x1400162af", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400162af", + "size": 4, + "mnemonic": "and", + "operands": "rcx, 0xfffffffffffffff0" + }, + { + "address": "0x1400162b3", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rcx" + }, + { + "address": "0x1400162b6", + "size": 5, + "mnemonic": "call", + "operands": "0x1400057a0" + }, + { + "address": "0x1400162bb", + "size": 3, + "mnemonic": "sub", + "operands": "rsp, rcx" + }, + { + "address": "0x1400162be", + "size": 5, + "mnemonic": "lea", + "operands": "rbx, [rsp + 0x50]" + }, + { + "address": "0x1400162c3", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x1400162c6", + "size": 6, + "mnemonic": "je", + "operands": "0x1400164d1" + } + ], + "successors": [ + "0x1400164d1", + "0x1400162cc" + ] + }, + { + "address": "0x1400162ac", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400162ac", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r8" + }, + { + "address": "0x1400162af", + "size": 4, + "mnemonic": "and", + "operands": "rcx, 0xfffffffffffffff0" + }, + { + "address": "0x1400162b3", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rcx" + }, + { + "address": "0x1400162b6", + "size": 5, + "mnemonic": "call", + "operands": "0x1400057a0" + }, + { + "address": "0x1400162bb", + "size": 3, + "mnemonic": "sub", + "operands": "rsp, rcx" + }, + { + "address": "0x1400162be", + "size": 5, + "mnemonic": "lea", + "operands": "rbx, [rsp + 0x50]" + }, + { + "address": "0x1400162c3", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x1400162c6", + "size": 6, + "mnemonic": "je", + "operands": "0x1400164d1" + } + ], + "successors": [ + "0x1400164d1", + "0x1400162cc" + ] + }, + { + "address": "0x1400164d1", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400164d1", + "size": 2, + "mnemonic": "mov", + "operands": "esi, edx" + }, + { + "address": "0x1400164d3", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x1400164d6", + "size": 2, + "mnemonic": "je", + "operands": "0x1400164e9" + } + ], + "successors": [ + "0x1400164e9", + "0x1400164d8" + ] + }, + { + "address": "0x1400162f9", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400162f9", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], r15d" + }, + { + "address": "0x1400162fe", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, edi" + }, + { + "address": "0x140016301", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rsi" + }, + { + "address": "0x140016304", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rbx" + }, + { + "address": "0x140016309", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 1" + }, + { + "address": "0x14001630e", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, r14d" + }, + { + "address": "0x140016311", + "size": 5, + "mnemonic": "call", + "operands": "0x14001702c" + }, + { + "address": "0x140016316", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140016318", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001631a", + "size": 6, + "mnemonic": "je", + "operands": "0x1400164d1" + } + ], + "successors": [ + "0x1400164d1", + "0x140016320" + ] + }, + { + "address": "0x1400162cc", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400162cc", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rbx], 0xcccc" + }, + { + "address": "0x1400162d2", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400162ec" + } + ], + "successors": [ + "0x1400162ec" + ] + }, + { + "address": "0x140016320", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016320", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x40], rdx" + }, + { + "address": "0x140016325", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, r15d" + }, + { + "address": "0x140016328", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], rdx" + }, + { + "address": "0x14001632d", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rbx" + }, + { + "address": "0x140016330", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rdx" + }, + { + "address": "0x140016335", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r13" + }, + { + "address": "0x140016338", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], edx" + }, + { + "address": "0x14001633c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rdx" + }, + { + "address": "0x140016341", + "size": 3, + "mnemonic": "mov", + "operands": "edx, r12d" + }, + { + "address": "0x140016344", + "size": 5, + "mnemonic": "call", + "operands": "0x1400121ec" + }, + { + "address": "0x140016349", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14001634b", + "size": 3, + "mnemonic": "movsxd", + "operands": "rsi, eax" + }, + { + "address": "0x14001634e", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140016350", + "size": 6, + "mnemonic": "je", + "operands": "0x1400164d1" + } + ], + "successors": [ + "0x1400164d1", + "0x140016356" + ] + }, + { + "address": "0x1400162ec", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400162ec", + "size": 4, + "mnemonic": "add", + "operands": "rbx, 0x10" + }, + { + "address": "0x1400162f0", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x1400162f3", + "size": 6, + "mnemonic": "je", + "operands": "0x1400164d1" + } + ], + "successors": [ + "0x1400164d1", + "0x1400162f9" + ] + }, + { + "address": "0x140016356", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016356", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x400" + }, + { + "address": "0x14001635c", + "size": 3, + "mnemonic": "test", + "operands": "r8d, r12d" + }, + { + "address": "0x14001635f", + "size": 2, + "mnemonic": "je", + "operands": "0x1400163b2" + } + ], + "successors": [ + "0x1400163b2", + "0x140016361" + ] + }, + { + "address": "0x1400163b2", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400163b2", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x1400163b5", + "size": 3, + "mnemonic": "add", + "operands": "rcx, rcx" + }, + { + "address": "0x1400163b8", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rcx + 0x10]" + }, + { + "address": "0x1400163bc", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, rax" + }, + { + "address": "0x1400163bf", + "size": 3, + "mnemonic": "sbb", + "operands": "rcx, rcx" + }, + { + "address": "0x1400163c2", + "size": 3, + "mnemonic": "and", + "operands": "rcx, rax" + }, + { + "address": "0x1400163c5", + "size": 6, + "mnemonic": "je", + "operands": "0x1400164b1" + } + ], + "successors": [ + "0x1400164b1", + "0x1400163cb" + ] + }, + { + "address": "0x140016361", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016361", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbp + 0x70]" + }, + { + "address": "0x140016364", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140016366", + "size": 6, + "mnemonic": "je", + "operands": "0x1400164d8" + } + ], + "successors": [ + "0x1400164d8", + "0x14001636c" + ] + }, + { + "address": "0x1400164b1", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400164b1", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x1400164b4", + "size": 3, + "mnemonic": "test", + "operands": "rdi, rdi" + }, + { + "address": "0x1400164b7", + "size": 2, + "mnemonic": "je", + "operands": "0x1400164ca" + } + ], + "successors": [ + "0x1400164ca", + "0x1400164b9" + ] + }, + { + "address": "0x1400163cb", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400163cb", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, r8" + }, + { + "address": "0x1400163ce", + "size": 2, + "mnemonic": "ja", + "operands": "0x140016405" + } + ], + "successors": [ + "0x140016405", + "0x1400163d0" + ] + }, + { + "address": "0x14001636c", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001636c", + "size": 2, + "mnemonic": "cmp", + "operands": "esi, eax" + }, + { + "address": "0x14001636e", + "size": 6, + "mnemonic": "jg", + "operands": "0x1400164d1" + } + ], + "successors": [ + "0x1400164d1", + "0x140016374" + ] + }, + { + "address": "0x1400164ca", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400164ca", + "size": 2, + "mnemonic": "xor", + "operands": "esi, esi" + }, + { + "address": "0x1400164cc", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400164d8" + } + ], + "successors": [ + "0x1400164d8" + ] + }, + { + "address": "0x1400164b9", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400164b9", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rdi - 0x10]" + }, + { + "address": "0x1400164bd", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rcx], 0xdddd" + }, + { + "address": "0x1400164c3", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400164ca" + }, + { + "address": "0x1400164c5", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x1400164ca", + "size": 2, + "mnemonic": "xor", + "operands": "esi, esi" + }, + { + "address": "0x1400164cc", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400164d8" + } + ], + "successors": [ + "0x1400164d8" + ] + }, + { + "address": "0x140016405", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016405", + "size": 5, + "mnemonic": "call", + "operands": "0x140015200" + }, + { + "address": "0x14001640a", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14001640c", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rax" + }, + { + "address": "0x14001640f", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140016412", + "size": 2, + "mnemonic": "je", + "operands": "0x14001641e" + } + ], + "successors": [ + "0x14001641e", + "0x140016414" + ] + }, + { + "address": "0x1400163d0", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400163d0", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rcx + 0xf]" + }, + { + "address": "0x1400163d4", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, rcx" + }, + { + "address": "0x1400163d7", + "size": 2, + "mnemonic": "ja", + "operands": "0x1400163e3" + } + ], + "successors": [ + "0x1400163e3", + "0x1400163d9" + ] + }, + { + "address": "0x140016374", + "size": 16, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016374", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x40], rdx" + }, + { + "address": "0x140016379", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, r15d" + }, + { + "address": "0x14001637c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], rdx" + }, + { + "address": "0x140016381", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rbx" + }, + { + "address": "0x140016384", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rdx" + }, + { + "address": "0x140016389", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r13" + }, + { + "address": "0x14001638c", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], eax" + }, + { + "address": "0x140016390", + "size": 3, + "mnemonic": "mov", + "operands": "edx, r12d" + }, + { + "address": "0x140016393", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x68]" + }, + { + "address": "0x140016397", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14001639c", + "size": 5, + "mnemonic": "call", + "operands": "0x1400121ec" + }, + { + "address": "0x1400163a1", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x1400163a3", + "size": 2, + "mnemonic": "mov", + "operands": "esi, eax" + }, + { + "address": "0x1400163a5", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x1400163a7", + "size": 6, + "mnemonic": "jne", + "operands": "0x1400164d8" + }, + { + "address": "0x1400163ad", + "size": 5, + "mnemonic": "jmp", + "operands": "0x1400164d1" + } + ], + "successors": [ + "0x1400164d1" + ] + }, + { + "address": "0x14001641e", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001641e", + "size": 3, + "mnemonic": "test", + "operands": "rdi, rdi" + }, + { + "address": "0x140016421", + "size": 6, + "mnemonic": "je", + "operands": "0x1400164ca" + } + ], + "successors": [ + "0x1400164ca", + "0x140016427" + ] + }, + { + "address": "0x140016414", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016414", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0xdddd" + }, + { + "address": "0x14001641a", + "size": 4, + "mnemonic": "add", + "operands": "rdi, 0x10" + }, + { + "address": "0x14001641e", + "size": 3, + "mnemonic": "test", + "operands": "rdi, rdi" + }, + { + "address": "0x140016421", + "size": 6, + "mnemonic": "je", + "operands": "0x1400164ca" + } + ], + "successors": [ + "0x1400164ca", + "0x140016427" + ] + }, + { + "address": "0x1400163e3", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400163e3", + "size": 4, + "mnemonic": "and", + "operands": "rax, 0xfffffffffffffff0" + }, + { + "address": "0x1400163e7", + "size": 5, + "mnemonic": "call", + "operands": "0x1400057a0" + }, + { + "address": "0x1400163ec", + "size": 3, + "mnemonic": "sub", + "operands": "rsp, rax" + }, + { + "address": "0x1400163ef", + "size": 5, + "mnemonic": "lea", + "operands": "rdi, [rsp + 0x50]" + }, + { + "address": "0x1400163f4", + "size": 3, + "mnemonic": "test", + "operands": "rdi, rdi" + }, + { + "address": "0x1400163f7", + "size": 6, + "mnemonic": "je", + "operands": "0x1400164ca" + } + ], + "successors": [ + "0x1400164ca", + "0x1400163fd" + ] + }, + { + "address": "0x1400163d9", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400163d9", + "size": 10, + "mnemonic": "movabs", + "operands": "rax, 0xffffffffffffff0" + }, + { + "address": "0x1400163e3", + "size": 4, + "mnemonic": "and", + "operands": "rax, 0xfffffffffffffff0" + }, + { + "address": "0x1400163e7", + "size": 5, + "mnemonic": "call", + "operands": "0x1400057a0" + }, + { + "address": "0x1400163ec", + "size": 3, + "mnemonic": "sub", + "operands": "rsp, rax" + }, + { + "address": "0x1400163ef", + "size": 5, + "mnemonic": "lea", + "operands": "rdi, [rsp + 0x50]" + }, + { + "address": "0x1400163f4", + "size": 3, + "mnemonic": "test", + "operands": "rdi, rdi" + }, + { + "address": "0x1400163f7", + "size": 6, + "mnemonic": "je", + "operands": "0x1400164ca" + } + ], + "successors": [ + "0x1400164ca", + "0x1400163fd" + ] + }, + { + "address": "0x140016427", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016427", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x40], rdx" + }, + { + "address": "0x14001642c", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, r15d" + }, + { + "address": "0x14001642f", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], rdx" + }, + { + "address": "0x140016434", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rbx" + }, + { + "address": "0x140016437", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rdx" + }, + { + "address": "0x14001643c", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r13" + }, + { + "address": "0x14001643f", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], esi" + }, + { + "address": "0x140016443", + "size": 3, + "mnemonic": "mov", + "operands": "edx, r12d" + }, + { + "address": "0x140016446", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rdi" + }, + { + "address": "0x14001644b", + "size": 5, + "mnemonic": "call", + "operands": "0x1400121ec" + }, + { + "address": "0x140016450", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140016452", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140016454", + "size": 2, + "mnemonic": "je", + "operands": "0x1400164b4" + } + ], + "successors": [ + "0x1400164b4", + "0x140016456" + ] + }, + { + "address": "0x1400163fd", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400163fd", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rdi], 0xcccc" + }, + { + "address": "0x140016403", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001641a" + } + ], + "successors": [ + "0x14001641a" + ] + }, + { + "address": "0x1400164b4", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400164b4", + "size": 3, + "mnemonic": "test", + "operands": "rdi, rdi" + }, + { + "address": "0x1400164b7", + "size": 2, + "mnemonic": "je", + "operands": "0x1400164ca" + } + ], + "successors": [ + "0x1400164ca", + "0x1400164b9" + ] + }, + { + "address": "0x140016456", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016456", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbp + 0x70]" + }, + { + "address": "0x140016459", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, esi" + }, + { + "address": "0x14001645c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], rdx" + }, + { + "address": "0x140016461", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rdi" + }, + { + "address": "0x140016464", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rdx" + }, + { + "address": "0x140016469", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, r14d" + }, + { + "address": "0x14001646c", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001646e", + "size": 2, + "mnemonic": "jne", + "operands": "0x140016486" + }, + { + "address": "0x140016470", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], edx" + }, + { + "address": "0x140016474", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rdx" + }, + { + "address": "0x140016479", + "size": 5, + "mnemonic": "call", + "operands": "0x1400170bc" + }, + { + "address": "0x14001647e", + "size": 2, + "mnemonic": "mov", + "operands": "esi, eax" + }, + { + "address": "0x140016480", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140016482", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001649e" + }, + { + "address": "0x140016484", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400164b4" + } + ], + "successors": [ + "0x1400164b4" + ] + }, + { + "address": "0x14001641a", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001641a", + "size": 4, + "mnemonic": "add", + "operands": "rdi, 0x10" + }, + { + "address": "0x14001641e", + "size": 3, + "mnemonic": "test", + "operands": "rdi, rdi" + }, + { + "address": "0x140016421", + "size": 6, + "mnemonic": "je", + "operands": "0x1400164ca" + } + ], + "successors": [ + "0x1400164ca", + "0x140016427" + ] + } + ] + }, + { + "address": "0x140016bca", + "name": "", + "blocks": [ + { + "address": "0x140016bca", + "size": 29, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016bca", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140016bcb", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140016bcc", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140016bcd", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140016bcf", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140016bd1", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140016bd3", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x140016bd7", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x1a462]" + }, + { + "address": "0x140016bde", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x140016be1", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rax" + }, + { + "address": "0x140016be6", + "size": 8, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0xa0]" + }, + { + "address": "0x140016bee", + "size": 7, + "mnemonic": "lea", + "operands": "rbx, [rip + 0x1cb4b]" + }, + { + "address": "0x140016bf5", + "size": 3, + "mnemonic": "xor", + "operands": "r12d, r12d" + }, + { + "address": "0x140016bf8", + "size": 7, + "mnemonic": "lea", + "operands": "rdi, [rip + 0xa881]" + }, + { + "address": "0x140016bff", + "size": 3, + "mnemonic": "test", + "operands": "r9, r9" + }, + { + "address": "0x140016c02", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdx" + }, + { + "address": "0x140016c05", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rdx" + }, + { + "address": "0x140016c08", + "size": 4, + "mnemonic": "cmovne", + "operands": "rbx, r9" + }, + { + "address": "0x140016c0c", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x140016c0f", + "size": 5, + "mnemonic": "lea", + "operands": "ebp, [r12 + 1]" + }, + { + "address": "0x140016c14", + "size": 4, + "mnemonic": "cmovne", + "operands": "rbp, r8" + }, + { + "address": "0x140016c18", + "size": 4, + "mnemonic": "cmovne", + "operands": "rdi, rdx" + }, + { + "address": "0x140016c1c", + "size": 3, + "mnemonic": "neg", + "operands": "rax" + }, + { + "address": "0x140016c1f", + "size": 3, + "mnemonic": "sbb", + "operands": "r14, r14" + }, + { + "address": "0x140016c22", + "size": 3, + "mnemonic": "and", + "operands": "r14, rcx" + }, + { + "address": "0x140016c25", + "size": 3, + "mnemonic": "test", + "operands": "rbp, rbp" + }, + { + "address": "0x140016c28", + "size": 2, + "mnemonic": "jne", + "operands": "0x140016c36" + }, + { + "address": "0x140016c2a", + "size": 7, + "mnemonic": "mov", + "operands": "rax, 0xfffffffffffffffe" + }, + { + "address": "0x140016c31", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140016d69" + } + ], + "successors": [ + "0x140016d69" + ] + }, + { + "address": "0x140016d69", + "size": 12, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140016d69", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140016d6e", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x140016d71", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140016d76", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x40" + }, + { + "address": "0x140016d7a", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140016d7c", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140016d7e", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140016d80", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140016d81", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140016d82", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140016d83", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140016d84", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140017260", + "name": "", + "blocks": [ + { + "address": "0x140017260", + "size": 15, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x140017260", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140017262", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140017263", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x48" + }, + { + "address": "0x140017267", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rdx" + }, + { + "address": "0x14001726a", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rcx" + }, + { + "address": "0x14001726d", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140017270", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001728e" + }, + { + "address": "0x140017272", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x140017277", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0x16" + }, + { + "address": "0x14001727d", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afb4" + }, + { + "address": "0x140017282", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x7fffffff" + }, + { + "address": "0x140017287", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x48" + }, + { + "address": "0x14001728b", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14001728c", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001728d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140017819", + "name": "", + "blocks": [ + { + "address": "0x140017819", + "size": 20, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017819", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001781a", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x14001781b", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001781c", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x14001781e", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140017820", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140017822", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140017824", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x140017827", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x50" + }, + { + "address": "0x14001782b", + "size": 3, + "mnemonic": "xor", + "operands": "r15d, r15d" + }, + { + "address": "0x14001782e", + "size": 3, + "mnemonic": "mov", + "operands": "r13, rdx" + }, + { + "address": "0x140017831", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140017834", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x140017837", + "size": 2, + "mnemonic": "jne", + "operands": "0x140017850" + }, + { + "address": "0x140017839", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x14001783e", + "size": 4, + "mnemonic": "lea", + "operands": "ebx, [r13 + 0x16]" + }, + { + "address": "0x140017842", + "size": 2, + "mnemonic": "mov", + "operands": "dword ptr [rax], ebx" + }, + { + "address": "0x140017844", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afb4" + }, + { + "address": "0x140017849", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ebx" + }, + { + "address": "0x14001784b", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140017a20" + } + ], + "successors": [ + "0x140017a20" + ] + }, + { + "address": "0x140017a20", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140017a20", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x90]" + }, + { + "address": "0x140017a28", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x50" + }, + { + "address": "0x140017a2c", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140017a2e", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140017a30", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140017a32", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140017a34", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140017a35", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140017a36", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140017a37", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140017bd4", + "name": "", + "blocks": [ + { + "address": "0x140017bd4", + "size": 17, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017bd4", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140017bd6", + "size": 1, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140017bd7", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140017bd8", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140017bd9", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140017bdb", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140017bdd", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140017bdf", + "size": 8, + "mnemonic": "lea", + "operands": "rbp, [rsp - 0x240]" + }, + { + "address": "0x140017be7", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x340" + }, + { + "address": "0x140017bee", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x1944b]" + }, + { + "address": "0x140017bf5", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x140017bf8", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x230], rax" + }, + { + "address": "0x140017bff", + "size": 3, + "mnemonic": "mov", + "operands": "r12, r8" + }, + { + "address": "0x140017c02", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x140017c05", + "size": 10, + "mnemonic": "movabs", + "operands": "rbx, 0x200000000801" + }, + { + "address": "0x140017c0f", + "size": 3, + "mnemonic": "cmp", + "operands": "rdx, rcx" + }, + { + "address": "0x140017c12", + "size": 2, + "mnemonic": "je", + "operands": "0x140017c36" + } + ], + "successors": [ + "0x140017c36", + "0x140017c14" + ] + }, + { + "address": "0x140017c36", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017c36", + "size": 3, + "mnemonic": "mov", + "operands": "r8b, byte ptr [rdx]" + }, + { + "address": "0x140017c39", + "size": 4, + "mnemonic": "cmp", + "operands": "r8b, 0x3a" + }, + { + "address": "0x140017c3d", + "size": 2, + "mnemonic": "jne", + "operands": "0x140017c5d" + }, + { + "address": "0x140017c3f", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rdi + 1]" + }, + { + "address": "0x140017c43", + "size": 3, + "mnemonic": "cmp", + "operands": "rdx, rax" + }, + { + "address": "0x140017c46", + "size": 2, + "mnemonic": "je", + "operands": "0x140017c5d" + } + ], + "successors": [ + "0x140017c5d", + "0x140017c48" + ] + }, + { + "address": "0x140017c14", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017c14", + "size": 2, + "mnemonic": "mov", + "operands": "al, byte ptr [rdx]" + }, + { + "address": "0x140017c16", + "size": 2, + "mnemonic": "sub", + "operands": "al, 0x2f" + }, + { + "address": "0x140017c18", + "size": 2, + "mnemonic": "cmp", + "operands": "al, 0x2d" + }, + { + "address": "0x140017c1a", + "size": 2, + "mnemonic": "ja", + "operands": "0x140017c26" + } + ], + "successors": [ + "0x140017c26", + "0x140017c1c" + ] + }, + { + "address": "0x140017c5d", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017c5d", + "size": 4, + "mnemonic": "sub", + "operands": "r8b, 0x2f" + }, + { + "address": "0x140017c61", + "size": 3, + "mnemonic": "xor", + "operands": "r14d, r14d" + }, + { + "address": "0x140017c64", + "size": 4, + "mnemonic": "cmp", + "operands": "r8b, 0x2d" + }, + { + "address": "0x140017c68", + "size": 2, + "mnemonic": "ja", + "operands": "0x140017c76" + } + ], + "successors": [ + "0x140017c76", + "0x140017c6a" + ] + }, + { + "address": "0x140017c48", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017c48", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r12" + }, + { + "address": "0x140017c4b", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x140017c4e", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140017c50", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140017c53", + "size": 5, + "mnemonic": "call", + "operands": "0x140017a50" + }, + { + "address": "0x140017c58", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140017f11" + } + ], + "successors": [ + "0x140017f11" + ] + }, + { + "address": "0x140017c26", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017c26", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140017c29", + "size": 5, + "mnemonic": "call", + "operands": "0x14001cea8" + }, + { + "address": "0x140017c2e", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rax" + }, + { + "address": "0x140017c31", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, rdi" + }, + { + "address": "0x140017c34", + "size": 2, + "mnemonic": "jne", + "operands": "0x140017c14" + }, + { + "address": "0x140017c36", + "size": 3, + "mnemonic": "mov", + "operands": "r8b, byte ptr [rdx]" + }, + { + "address": "0x140017c39", + "size": 4, + "mnemonic": "cmp", + "operands": "r8b, 0x3a" + }, + { + "address": "0x140017c3d", + "size": 2, + "mnemonic": "jne", + "operands": "0x140017c5d" + }, + { + "address": "0x140017c3f", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rdi + 1]" + }, + { + "address": "0x140017c43", + "size": 3, + "mnemonic": "cmp", + "operands": "rdx, rax" + }, + { + "address": "0x140017c46", + "size": 2, + "mnemonic": "je", + "operands": "0x140017c5d" + } + ], + "successors": [ + "0x140017c5d", + "0x140017c48" + ] + }, + { + "address": "0x140017c1c", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017c1c", + "size": 4, + "mnemonic": "movsx", + "operands": "rax, al" + }, + { + "address": "0x140017c20", + "size": 4, + "mnemonic": "bt", + "operands": "rbx, rax" + }, + { + "address": "0x140017c24", + "size": 2, + "mnemonic": "jb", + "operands": "0x140017c36" + } + ], + "successors": [ + "0x140017c36", + "0x140017c26" + ] + }, + { + "address": "0x140017c76", + "size": 26, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017c76", + "size": 3, + "mnemonic": "mov", + "operands": "al, r14b" + }, + { + "address": "0x140017c79", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, rdi" + }, + { + "address": "0x140017c7c", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x20]" + }, + { + "address": "0x140017c80", + "size": 3, + "mnemonic": "inc", + "operands": "rdx" + }, + { + "address": "0x140017c83", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x250" + }, + { + "address": "0x140017c89", + "size": 2, + "mnemonic": "neg", + "operands": "al" + }, + { + "address": "0x140017c8b", + "size": 3, + "mnemonic": "sbb", + "operands": "r13, r13" + }, + { + "address": "0x140017c8e", + "size": 3, + "mnemonic": "and", + "operands": "r13, rdx" + }, + { + "address": "0x140017c91", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140017c93", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], r13" + }, + { + "address": "0x140017c98", + "size": 5, + "mnemonic": "call", + "operands": "0x14001ea80" + }, + { + "address": "0x140017c9d", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140017c9f", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x40], r14" + }, + { + "address": "0x140017ca4", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x70]" + }, + { + "address": "0x140017ca9", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x48], r14" + }, + { + "address": "0x140017cae", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x50], r14" + }, + { + "address": "0x140017cb3", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x58], r14" + }, + { + "address": "0x140017cb8", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x60], r14" + }, + { + "address": "0x140017cbd", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x68], r14b" + }, + { + "address": "0x140017cc2", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d89c" + }, + { + "address": "0x140017cc7", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x78]" + }, + { + "address": "0x140017ccc", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0xfde9" + }, + { + "address": "0x140017cd1", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rax + 0xc], ecx" + }, + { + "address": "0x140017cd4", + "size": 2, + "mnemonic": "jne", + "operands": "0x140017ced" + }, + { + "address": "0x140017cd6", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x78], r14b" + }, + { + "address": "0x140017cda", + "size": 2, + "mnemonic": "je", + "operands": "0x140017ce8" + } + ], + "successors": [ + "0x140017ce8", + "0x140017cdc" + ] + }, + { + "address": "0x140017c6a", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017c6a", + "size": 4, + "mnemonic": "movsx", + "operands": "rax, r8b" + }, + { + "address": "0x140017c6e", + "size": 4, + "mnemonic": "bt", + "operands": "rbx, rax" + }, + { + "address": "0x140017c72", + "size": 2, + "mnemonic": "mov", + "operands": "al, 1" + }, + { + "address": "0x140017c74", + "size": 2, + "mnemonic": "jb", + "operands": "0x140017c79" + } + ], + "successors": [ + "0x140017c79", + "0x140017c76" + ] + }, + { + "address": "0x140017f11", + "size": 12, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140017f11", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x230]" + }, + { + "address": "0x140017f18", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x140017f1b", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140017f20", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0x340" + }, + { + "address": "0x140017f27", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140017f29", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140017f2b", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140017f2d", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140017f2e", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140017f2f", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140017f30", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140017f31", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140017ce8", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017ce8", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, ecx" + }, + { + "address": "0x140017ceb", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140017d25" + } + ], + "successors": [ + "0x140017d25" + ] + }, + { + "address": "0x140017cdc", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017cdc", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140017ce1", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rax + 0x3a8], 0xfffffffd" + }, + { + "address": "0x140017ce8", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, ecx" + }, + { + "address": "0x140017ceb", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140017d25" + } + ], + "successors": [ + "0x140017d25" + ] + }, + { + "address": "0x140017c79", + "size": 25, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017c79", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, rdi" + }, + { + "address": "0x140017c7c", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x20]" + }, + { + "address": "0x140017c80", + "size": 3, + "mnemonic": "inc", + "operands": "rdx" + }, + { + "address": "0x140017c83", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x250" + }, + { + "address": "0x140017c89", + "size": 2, + "mnemonic": "neg", + "operands": "al" + }, + { + "address": "0x140017c8b", + "size": 3, + "mnemonic": "sbb", + "operands": "r13, r13" + }, + { + "address": "0x140017c8e", + "size": 3, + "mnemonic": "and", + "operands": "r13, rdx" + }, + { + "address": "0x140017c91", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140017c93", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], r13" + }, + { + "address": "0x140017c98", + "size": 5, + "mnemonic": "call", + "operands": "0x14001ea80" + }, + { + "address": "0x140017c9d", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140017c9f", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x40], r14" + }, + { + "address": "0x140017ca4", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x70]" + }, + { + "address": "0x140017ca9", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x48], r14" + }, + { + "address": "0x140017cae", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x50], r14" + }, + { + "address": "0x140017cb3", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x58], r14" + }, + { + "address": "0x140017cb8", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x60], r14" + }, + { + "address": "0x140017cbd", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x68], r14b" + }, + { + "address": "0x140017cc2", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d89c" + }, + { + "address": "0x140017cc7", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x78]" + }, + { + "address": "0x140017ccc", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0xfde9" + }, + { + "address": "0x140017cd1", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rax + 0xc], ecx" + }, + { + "address": "0x140017cd4", + "size": 2, + "mnemonic": "jne", + "operands": "0x140017ced" + }, + { + "address": "0x140017cd6", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x78], r14b" + }, + { + "address": "0x140017cda", + "size": 2, + "mnemonic": "je", + "operands": "0x140017ce8" + } + ], + "successors": [ + "0x140017ce8", + "0x140017cdc" + ] + }, + { + "address": "0x140017d25", + "size": 24, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017d25", + "size": 5, + "mnemonic": "lea", + "operands": "r8, [rsp + 0x30]" + }, + { + "address": "0x140017d2a", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140017d2d", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x40]" + }, + { + "address": "0x140017d32", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d9d8" + }, + { + "address": "0x140017d37", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x50]" + }, + { + "address": "0x140017d3c", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbp - 0x20]" + }, + { + "address": "0x140017d40", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140017d42", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], r14d" + }, + { + "address": "0x140017d47", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r14" + }, + { + "address": "0x140017d4c", + "size": 4, + "mnemonic": "cmovne", + "operands": "rcx, r14" + }, + { + "address": "0x140017d50", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x140017d53", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140017d55", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x84e5]" + }, + { + "address": "0x140017d5b", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x140017d5e", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, -1" + }, + { + "address": "0x140017d62", + "size": 2, + "mnemonic": "jne", + "operands": "0x140017d8e" + }, + { + "address": "0x140017d64", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r12" + }, + { + "address": "0x140017d67", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x140017d6a", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140017d6c", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140017d6f", + "size": 5, + "mnemonic": "call", + "operands": "0x140017a50" + }, + { + "address": "0x140017d74", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, eax" + }, + { + "address": "0x140017d76", + "size": 5, + "mnemonic": "cmp", + "operands": "byte ptr [rsp + 0x68], r14b" + }, + { + "address": "0x140017d7b", + "size": 2, + "mnemonic": "je", + "operands": "0x140017d87" + } + ], + "successors": [ + "0x140017d87", + "0x140017d7d" + ] + }, + { + "address": "0x140017d87", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017d87", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ebx" + }, + { + "address": "0x140017d89", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140017f11" + } + ], + "successors": [ + "0x140017f11" + ] + }, + { + "address": "0x140017d7d", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017d7d", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x50]" + }, + { + "address": "0x140017d82", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140017d87", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ebx" + }, + { + "address": "0x140017d89", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140017f11" + } + ], + "successors": [ + "0x140017f11" + ] + } + ] + }, + { + "address": "0x140017f46", + "name": "", + "blocks": [ + { + "address": "0x140017f46", + "size": 18, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017f46", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140017f47", + "size": 8, + "mnemonic": "lea", + "operands": "rbp, [rsp - 0x1a0]" + }, + { + "address": "0x140017f4f", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x2a0" + }, + { + "address": "0x140017f56", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x190e3]" + }, + { + "address": "0x140017f5d", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x140017f60", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x190], rax" + }, + { + "address": "0x140017f67", + "size": 3, + "mnemonic": "mov", + "operands": "edi, r8d" + }, + { + "address": "0x140017f6a", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdx" + }, + { + "address": "0x140017f6d", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x105" + }, + { + "address": "0x140017f73", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x80]" + }, + { + "address": "0x140017f77", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x81db]" + }, + { + "address": "0x140017f7d", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140017f7f", + "size": 2, + "mnemonic": "jne", + "operands": "0x140017f95" + }, + { + "address": "0x140017f81", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x8171]" + }, + { + "address": "0x140017f87", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, eax" + }, + { + "address": "0x140017f89", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d808" + }, + { + "address": "0x140017f8e", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140017f90", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140018039" + } + ], + "successors": [ + "0x140018039" + ] + }, + { + "address": "0x140018039", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140018039", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x190]" + }, + { + "address": "0x140018040", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x140018043", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140018048", + "size": 8, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x2a0]" + }, + { + "address": "0x140018050", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x18]" + }, + { + "address": "0x140018054", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x20]" + }, + { + "address": "0x140018058", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x14001805b", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001805c", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140018352", + "name": "", + "blocks": [ + { + "address": "0x140018352", + "size": 14, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140018352", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140018353", + "size": 8, + "mnemonic": "lea", + "operands": "rbp, [rsp - 0x680]" + }, + { + "address": "0x14001835b", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x780" + }, + { + "address": "0x140018362", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x18cd7]" + }, + { + "address": "0x140018369", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x14001836c", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x670], rax" + }, + { + "address": "0x140018373", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140018375", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x140018378", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rcx + 4]" + }, + { + "address": "0x14001837b", + "size": 3, + "mnemonic": "xorps", + "operands": "xmm0, xmm0" + }, + { + "address": "0x14001837e", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x60], eax" + }, + { + "address": "0x140018382", + "size": 5, + "mnemonic": "movups", + "operands": "xmmword ptr [rsp + 0x50], xmm0" + }, + { + "address": "0x140018387", + "size": 6, + "mnemonic": "cmp", + "operands": "ecx, 0xfde9" + }, + { + "address": "0x14001838d", + "size": 6, + "mnemonic": "je", + "operands": "0x1400184da" + } + ], + "successors": [ + "0x1400184da", + "0x140018393" + ] + }, + { + "address": "0x1400184da", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400184da", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x1400184dc", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rdi + 0x19]" + }, + { + "address": "0x1400184e0", + "size": 5, + "mnemonic": "mov", + "operands": "ebx, 0x100" + }, + { + "address": "0x1400184e5", + "size": 4, + "mnemonic": "lea", + "operands": "r8d, [rdx - 0x61]" + }, + { + "address": "0x1400184e9", + "size": 4, + "mnemonic": "lea", + "operands": "eax, [r8 + 0x20]" + }, + { + "address": "0x1400184ed", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 0x19" + }, + { + "address": "0x1400184f0", + "size": 2, + "mnemonic": "ja", + "operands": "0x1400184fa" + } + ], + "successors": [ + "0x1400184fa", + "0x1400184f2" + ] + }, + { + "address": "0x140018393", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140018393", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x50]" + }, + { + "address": "0x140018398", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x7cb2]" + }, + { + "address": "0x14001839e", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x1400183a0", + "size": 6, + "mnemonic": "je", + "operands": "0x1400184da" + } + ], + "successors": [ + "0x1400184da", + "0x1400183a6" + ] + }, + { + "address": "0x1400184fa", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400184fa", + "size": 4, + "mnemonic": "cmp", + "operands": "r8d, 0x19" + }, + { + "address": "0x1400184fe", + "size": 2, + "mnemonic": "ja", + "operands": "0x140018508" + } + ], + "successors": [ + "0x140018508", + "0x140018500" + ] + }, + { + "address": "0x1400184f2", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400184f2", + "size": 3, + "mnemonic": "or", + "operands": "byte ptr [rcx], 0x10" + }, + { + "address": "0x1400184f5", + "size": 3, + "mnemonic": "lea", + "operands": "eax, [rdx + 0x20]" + }, + { + "address": "0x1400184f8", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001850a" + } + ], + "successors": [ + "0x14001850a" + ] + }, + { + "address": "0x1400183a6", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400183a6", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x1400183a8", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x70]" + }, + { + "address": "0x1400183ad", + "size": 5, + "mnemonic": "mov", + "operands": "ebx, 0x100" + }, + { + "address": "0x1400183b2", + "size": 2, + "mnemonic": "mov", + "operands": "byte ptr [rcx], al" + }, + { + "address": "0x1400183b4", + "size": 2, + "mnemonic": "inc", + "operands": "eax" + }, + { + "address": "0x1400183b6", + "size": 3, + "mnemonic": "inc", + "operands": "rcx" + }, + { + "address": "0x1400183b9", + "size": 2, + "mnemonic": "cmp", + "operands": "eax, ebx" + }, + { + "address": "0x1400183bb", + "size": 2, + "mnemonic": "jb", + "operands": "0x1400183b2" + } + ], + "successors": [ + "0x1400183b2", + "0x1400183bd" + ] + }, + { + "address": "0x140018508", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140018508", + "size": 2, + "mnemonic": "xor", + "operands": "al, al" + }, + { + "address": "0x14001850a", + "size": 6, + "mnemonic": "mov", + "operands": "byte ptr [rcx + 0x100], al" + }, + { + "address": "0x140018510", + "size": 2, + "mnemonic": "inc", + "operands": "edx" + }, + { + "address": "0x140018512", + "size": 3, + "mnemonic": "inc", + "operands": "rcx" + }, + { + "address": "0x140018515", + "size": 2, + "mnemonic": "cmp", + "operands": "edx, ebx" + }, + { + "address": "0x140018517", + "size": 2, + "mnemonic": "jb", + "operands": "0x1400184e5" + } + ], + "successors": [ + "0x1400184e5", + "0x140018519" + ] + }, + { + "address": "0x140018500", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140018500", + "size": 3, + "mnemonic": "or", + "operands": "byte ptr [rcx], 0x20" + }, + { + "address": "0x140018503", + "size": 3, + "mnemonic": "lea", + "operands": "eax, [rdx - 0x20]" + }, + { + "address": "0x140018506", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001850a" + } + ], + "successors": [ + "0x14001850a" + ] + }, + { + "address": "0x14001850a", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001850a", + "size": 6, + "mnemonic": "mov", + "operands": "byte ptr [rcx + 0x100], al" + }, + { + "address": "0x140018510", + "size": 2, + "mnemonic": "inc", + "operands": "edx" + }, + { + "address": "0x140018512", + "size": 3, + "mnemonic": "inc", + "operands": "rcx" + }, + { + "address": "0x140018515", + "size": 2, + "mnemonic": "cmp", + "operands": "edx, ebx" + }, + { + "address": "0x140018517", + "size": 2, + "mnemonic": "jb", + "operands": "0x1400184e5" + } + ], + "successors": [ + "0x1400184e5", + "0x140018519" + ] + }, + { + "address": "0x1400183b2", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400183b2", + "size": 2, + "mnemonic": "mov", + "operands": "byte ptr [rcx], al" + }, + { + "address": "0x1400183b4", + "size": 2, + "mnemonic": "inc", + "operands": "eax" + }, + { + "address": "0x1400183b6", + "size": 3, + "mnemonic": "inc", + "operands": "rcx" + }, + { + "address": "0x1400183b9", + "size": 2, + "mnemonic": "cmp", + "operands": "eax, ebx" + }, + { + "address": "0x1400183bb", + "size": 2, + "mnemonic": "jb", + "operands": "0x1400183b2" + } + ], + "successors": [ + "0x1400183b2", + "0x1400183bd" + ] + }, + { + "address": "0x1400183bd", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400183bd", + "size": 4, + "mnemonic": "mov", + "operands": "al, byte ptr [rsp + 0x56]" + }, + { + "address": "0x1400183c1", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x56]" + }, + { + "address": "0x1400183c6", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x70], 0x20" + }, + { + "address": "0x1400183cb", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400183ed" + } + ], + "successors": [ + "0x1400183ed" + ] + }, + { + "address": "0x1400184e5", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400184e5", + "size": 4, + "mnemonic": "lea", + "operands": "r8d, [rdx - 0x61]" + }, + { + "address": "0x1400184e9", + "size": 4, + "mnemonic": "lea", + "operands": "eax, [r8 + 0x20]" + }, + { + "address": "0x1400184ed", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 0x19" + }, + { + "address": "0x1400184f0", + "size": 2, + "mnemonic": "ja", + "operands": "0x1400184fa" + } + ], + "successors": [ + "0x1400184fa", + "0x1400184f2" + ] + }, + { + "address": "0x140018519", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140018519", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x670]" + }, + { + "address": "0x140018520", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x140018523", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x140018528", + "size": 8, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x780]" + }, + { + "address": "0x140018530", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x18]" + }, + { + "address": "0x140018534", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x20]" + }, + { + "address": "0x140018538", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x14001853b", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001853c", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400183ed", + "size": 44, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400183ed", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x1400183ef", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400183cd" + }, + { + "address": "0x1400183f1", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdi + 4]" + }, + { + "address": "0x1400183f4", + "size": 5, + "mnemonic": "lea", + "operands": "r8, [rsp + 0x70]" + }, + { + "address": "0x1400183f9", + "size": 5, + "mnemonic": "and", + "operands": "dword ptr [rsp + 0x30], 0" + }, + { + "address": "0x1400183fe", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, ebx" + }, + { + "address": "0x140018401", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], eax" + }, + { + "address": "0x140018405", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 1" + }, + { + "address": "0x14001840a", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x270]" + }, + { + "address": "0x140018411", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x140018413", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x140018418", + "size": 5, + "mnemonic": "call", + "operands": "0x140016050" + }, + { + "address": "0x14001841d", + "size": 5, + "mnemonic": "and", + "operands": "dword ptr [rsp + 0x40], 0" + }, + { + "address": "0x140018422", + "size": 5, + "mnemonic": "lea", + "operands": "r9, [rsp + 0x70]" + }, + { + "address": "0x140018427", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdi + 4]" + }, + { + "address": "0x14001842a", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, ebx" + }, + { + "address": "0x14001842d", + "size": 7, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rdi + 0x220]" + }, + { + "address": "0x140018434", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x140018436", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x38], eax" + }, + { + "address": "0x14001843a", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x70]" + }, + { + "address": "0x14001843e", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x30], ebx" + }, + { + "address": "0x140018442", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x140018447", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x20], ebx" + }, + { + "address": "0x14001844b", + "size": 5, + "mnemonic": "call", + "operands": "0x140016514" + }, + { + "address": "0x140018450", + "size": 5, + "mnemonic": "and", + "operands": "dword ptr [rsp + 0x40], 0" + }, + { + "address": "0x140018455", + "size": 5, + "mnemonic": "lea", + "operands": "r9, [rsp + 0x70]" + }, + { + "address": "0x14001845a", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdi + 4]" + }, + { + "address": "0x14001845d", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x200" + }, + { + "address": "0x140018463", + "size": 7, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rdi + 0x220]" + }, + { + "address": "0x14001846a", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14001846c", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x38], eax" + }, + { + "address": "0x140018470", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x170]" + }, + { + "address": "0x140018477", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x30], ebx" + }, + { + "address": "0x14001847b", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x140018480", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x20], ebx" + }, + { + "address": "0x140018484", + "size": 5, + "mnemonic": "call", + "operands": "0x140016514" + }, + { + "address": "0x140018489", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbp + 0x70]" + }, + { + "address": "0x14001848d", + "size": 3, + "mnemonic": "sub", + "operands": "r8, rdi" + }, + { + "address": "0x140018490", + "size": 7, + "mnemonic": "lea", + "operands": "r9, [rbp + 0x170]" + }, + { + "address": "0x140018497", + "size": 3, + "mnemonic": "sub", + "operands": "r9, rdi" + }, + { + "address": "0x14001849a", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rbp + 0x270]" + }, + { + "address": "0x1400184a1", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rdi + 0x19]" + }, + { + "address": "0x1400184a5", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [rdx], 1" + }, + { + "address": "0x1400184a8", + "size": 2, + "mnemonic": "je", + "operands": "0x1400184b4" + } + ], + "successors": [ + "0x1400184b4", + "0x1400184aa" + ] + }, + { + "address": "0x1400184b4", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400184b4", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [rdx], 2" + }, + { + "address": "0x1400184b7", + "size": 2, + "mnemonic": "je", + "operands": "0x1400184c3" + } + ], + "successors": [ + "0x1400184c3", + "0x1400184b9" + ] + }, + { + "address": "0x1400184aa", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400184aa", + "size": 3, + "mnemonic": "or", + "operands": "byte ptr [rax], 0x10" + }, + { + "address": "0x1400184ad", + "size": 5, + "mnemonic": "mov", + "operands": "cl, byte ptr [r8 + rax - 0x19]" + }, + { + "address": "0x1400184b2", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400184c5" + } + ], + "successors": [ + "0x1400184c5" + ] + }, + { + "address": "0x1400184c3", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400184c3", + "size": 2, + "mnemonic": "xor", + "operands": "cl, cl" + }, + { + "address": "0x1400184c5", + "size": 6, + "mnemonic": "mov", + "operands": "byte ptr [rax + 0x100], cl" + }, + { + "address": "0x1400184cb", + "size": 4, + "mnemonic": "add", + "operands": "rdx, 2" + }, + { + "address": "0x1400184cf", + "size": 3, + "mnemonic": "inc", + "operands": "rax" + }, + { + "address": "0x1400184d2", + "size": 4, + "mnemonic": "sub", + "operands": "rbx, 1" + }, + { + "address": "0x1400184d6", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400184a5" + }, + { + "address": "0x1400184d8", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140018519" + } + ], + "successors": [ + "0x140018519" + ] + }, + { + "address": "0x1400184b9", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400184b9", + "size": 3, + "mnemonic": "or", + "operands": "byte ptr [rax], 0x20" + }, + { + "address": "0x1400184bc", + "size": 5, + "mnemonic": "mov", + "operands": "cl, byte ptr [rax + r9 - 0x19]" + }, + { + "address": "0x1400184c1", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400184c5" + } + ], + "successors": [ + "0x1400184c5" + ] + }, + { + "address": "0x1400184c5", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400184c5", + "size": 6, + "mnemonic": "mov", + "operands": "byte ptr [rax + 0x100], cl" + }, + { + "address": "0x1400184cb", + "size": 4, + "mnemonic": "add", + "operands": "rdx, 2" + }, + { + "address": "0x1400184cf", + "size": 3, + "mnemonic": "inc", + "operands": "rax" + }, + { + "address": "0x1400184d2", + "size": 4, + "mnemonic": "sub", + "operands": "rbx, 1" + }, + { + "address": "0x1400184d6", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400184a5" + }, + { + "address": "0x1400184d8", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140018519" + } + ], + "successors": [ + "0x140018519" + ] + } + ] + }, + { + "address": "0x140018553", + "name": "", + "blocks": [ + { + "address": "0x140018553", + "size": 19, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140018553", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140018554", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140018555", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140018557", + "size": 7, + "mnemonic": "lea", + "operands": "rbp, [rax - 0x188]" + }, + { + "address": "0x14001855e", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x270" + }, + { + "address": "0x140018565", + "size": 3, + "mnemonic": "mov", + "operands": "r14b, dl" + }, + { + "address": "0x140018568", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, ecx" + }, + { + "address": "0x14001856a", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r9" + }, + { + "address": "0x14001856d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r8" + }, + { + "address": "0x140018570", + "size": 5, + "mnemonic": "call", + "operands": "0x1400187b0" + }, + { + "address": "0x140018575", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x140018577", + "size": 5, + "mnemonic": "call", + "operands": "0x140018230" + }, + { + "address": "0x14001857c", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x1a0]" + }, + { + "address": "0x140018583", + "size": 2, + "mnemonic": "mov", + "operands": "edi, eax" + }, + { + "address": "0x140018585", + "size": 7, + "mnemonic": "mov", + "operands": "r8, qword ptr [rcx + 0x88]" + }, + { + "address": "0x14001858c", + "size": 4, + "mnemonic": "cmp", + "operands": "eax, dword ptr [r8 + 4]" + }, + { + "address": "0x140018590", + "size": 2, + "mnemonic": "jne", + "operands": "0x140018599" + }, + { + "address": "0x140018592", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140018594", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140018797" + } + ], + "successors": [ + "0x140018797" + ] + }, + { + "address": "0x140018797", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140018797", + "size": 8, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x270]" + }, + { + "address": "0x14001879f", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x20]" + }, + { + "address": "0x1400187a3", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x28]" + }, + { + "address": "0x1400187a7", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x1400187aa", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x1400187ac", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400187ad", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x1400187ae", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140018d4d", + "name": "", + "blocks": [ + { + "address": "0x140018d4d", + "size": 16, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140018d4d", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140018d4e", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140018d4f", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140018d50", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140018d52", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140018d54", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140018d56", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140018d58", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x140018d5c", + "size": 2, + "mnemonic": "xor", + "operands": "esi, esi" + }, + { + "address": "0x140018d5e", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, edx" + }, + { + "address": "0x140018d60", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rcx" + }, + { + "address": "0x140018d63", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140018d66", + "size": 2, + "mnemonic": "jne", + "operands": "0x140018d78" + }, + { + "address": "0x140018d68", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x140018d6d", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0x16" + }, + { + "address": "0x140018d73", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14001906b" + } + ], + "successors": [ + "0x14001906b" + ] + }, + { + "address": "0x14001906b", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001906b", + "size": 4, + "mnemonic": "or", + "operands": "rax, 0xffffffffffffffff" + }, + { + "address": "0x14001906f", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x80]" + }, + { + "address": "0x140019077", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001907b", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14001907d", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001907f", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140019081", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140019083", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140019084", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140019085", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140019086", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140019647", + "name": "", + "blocks": [ + { + "address": "0x140019647", + "size": 19, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019647", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140019648", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x14001964a", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x14001964c", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14001964e", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140019650", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x140019653", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x140019657", + "size": 3, + "mnemonic": "xor", + "operands": "r15d, r15d" + }, + { + "address": "0x14001965a", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x10], rcx" + }, + { + "address": "0x14001965e", + "size": 4, + "mnemonic": "and", + "operands": "qword ptr [rbp - 8], r15" + }, + { + "address": "0x140019662", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rcx" + }, + { + "address": "0x140019665", + "size": 7, + "mnemonic": "cmp", + "operands": "qword ptr [rcx + 0x140], r15" + }, + { + "address": "0x14001966c", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001968d" + }, + { + "address": "0x14001966e", + "size": 7, + "mnemonic": "cmp", + "operands": "qword ptr [rcx + 0x148], r15" + }, + { + "address": "0x140019675", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001968d" + }, + { + "address": "0x140019677", + "size": 3, + "mnemonic": "xor", + "operands": "r12d, r12d" + }, + { + "address": "0x14001967a", + "size": 7, + "mnemonic": "lea", + "operands": "rsi, [rip + 0x17b7f]" + }, + { + "address": "0x140019681", + "size": 7, + "mnemonic": "lea", + "operands": "rbx, [rcx + 0xf8]" + }, + { + "address": "0x140019688", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140019ae7" + } + ], + "successors": [ + "0x140019ae7" + ] + }, + { + "address": "0x140019ae7", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019ae7", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [r14 + 0xf0]" + }, + { + "address": "0x140019aee", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140019af1", + "size": 2, + "mnemonic": "je", + "operands": "0x140019af6" + } + ], + "successors": [ + "0x140019af6", + "0x140019af3" + ] + }, + { + "address": "0x140019af6", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019af6", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r14 + 0xe0]" + }, + { + "address": "0x140019afd", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140019b00", + "size": 2, + "mnemonic": "je", + "operands": "0x140019b22" + } + ], + "successors": [ + "0x140019b22", + "0x140019b02" + ] + }, + { + "address": "0x140019af3", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019af3", + "size": 3, + "mnemonic": "lock dec", + "operands": "dword ptr [rax]" + }, + { + "address": "0x140019af6", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r14 + 0xe0]" + }, + { + "address": "0x140019afd", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140019b00", + "size": 2, + "mnemonic": "je", + "operands": "0x140019b22" + } + ], + "successors": [ + "0x140019b22", + "0x140019b02" + ] + }, + { + "address": "0x140019b22", + "size": 15, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140019b22", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [r14 + 0xf0], r15" + }, + { + "address": "0x140019b29", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140019b2b", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [r14 + 0xe0], r12" + }, + { + "address": "0x140019b32", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rbx], rsi" + }, + { + "address": "0x140019b35", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x40]" + }, + { + "address": "0x140019b3a", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x30]" + }, + { + "address": "0x140019b3e", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x38]" + }, + { + "address": "0x140019b42", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x40]" + }, + { + "address": "0x140019b46", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x140019b49", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140019b4b", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140019b4d", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140019b4f", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140019b51", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140019b52", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140019b02", + "size": 23, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140019b02", + "size": 3, + "mnemonic": "or", + "operands": "eax, 0xffffffff" + }, + { + "address": "0x140019b05", + "size": 4, + "mnemonic": "lock xadd", + "operands": "dword ptr [rcx], eax" + }, + { + "address": "0x140019b09", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x140019b0c", + "size": 2, + "mnemonic": "jne", + "operands": "0x140019b22" + }, + { + "address": "0x140019b0e", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx]" + }, + { + "address": "0x140019b11", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140019b16", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r14 + 0xe0]" + }, + { + "address": "0x140019b1d", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140019b22", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [r14 + 0xf0], r15" + }, + { + "address": "0x140019b29", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140019b2b", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [r14 + 0xe0], r12" + }, + { + "address": "0x140019b32", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rbx], rsi" + }, + { + "address": "0x140019b35", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x40]" + }, + { + "address": "0x140019b3a", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x30]" + }, + { + "address": "0x140019b3e", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x38]" + }, + { + "address": "0x140019b42", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x40]" + }, + { + "address": "0x140019b46", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x140019b49", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140019b4b", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140019b4d", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140019b4f", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140019b51", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x140019b52", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140019eeb", + "name": "", + "blocks": [ + { + "address": "0x140019eeb", + "size": 209, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x140019eeb", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140019eec", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140019eee", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140019ef0", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140019ef2", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140019ef4", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x140019ef7", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x140019efb", + "size": 7, + "mnemonic": "mov", + "operands": "r14, qword ptr [rdx + 0x150]" + }, + { + "address": "0x140019f02", + "size": 3, + "mnemonic": "mov", + "operands": "r12, rcx" + }, + { + "address": "0x140019f05", + "size": 2, + "mnemonic": "xor", + "operands": "esi, esi" + }, + { + "address": "0x140019f07", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x10], rdx" + }, + { + "address": "0x140019f0b", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r14" + }, + { + "address": "0x140019f0e", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 8], rsi" + }, + { + "address": "0x140019f12", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ef78" + }, + { + "address": "0x140019f17", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [r12 + 0x2b8], rax" + }, + { + "address": "0x140019f1f", + "size": 4, + "mnemonic": "lea", + "operands": "r15d, [rsi + 0x31]" + }, + { + "address": "0x140019f23", + "size": 4, + "mnemonic": "lea", + "operands": "r13d, [rsi + 7]" + }, + { + "address": "0x140019f27", + "size": 4, + "mnemonic": "lea", + "operands": "ecx, [r15 - 0x30]" + }, + { + "address": "0x140019f2b", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x24924925" + }, + { + "address": "0x140019f30", + "size": 2, + "mnemonic": "mul", + "operands": "ecx" + }, + { + "address": "0x140019f32", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ecx" + }, + { + "address": "0x140019f34", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, r15d" + }, + { + "address": "0x140019f37", + "size": 2, + "mnemonic": "sub", + "operands": "eax, edx" + }, + { + "address": "0x140019f39", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x140019f3c", + "size": 2, + "mnemonic": "shr", + "operands": "eax, 1" + }, + { + "address": "0x140019f3e", + "size": 2, + "mnemonic": "add", + "operands": "eax, edx" + }, + { + "address": "0x140019f40", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 1" + }, + { + "address": "0x140019f45", + "size": 3, + "mnemonic": "shr", + "operands": "eax, 2" + }, + { + "address": "0x140019f48", + "size": 3, + "mnemonic": "imul", + "operands": "eax, eax, 7" + }, + { + "address": "0x140019f4b", + "size": 2, + "mnemonic": "sub", + "operands": "ecx, eax" + }, + { + "address": "0x140019f4d", + "size": 4, + "mnemonic": "lea", + "operands": "rdi, [r12 + rcx*8]" + }, + { + "address": "0x140019f51", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x140019f55", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rdi" + }, + { + "address": "0x140019f5a", + "size": 5, + "mnemonic": "call", + "operands": "0x140015e88" + }, + { + "address": "0x140019f5f", + "size": 2, + "mnemonic": "or", + "operands": "esi, eax" + }, + { + "address": "0x140019f61", + "size": 4, + "mnemonic": "lea", + "operands": "r9d, [r15 - 7]" + }, + { + "address": "0x140019f65", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rdi + 0x38]" + }, + { + "address": "0x140019f69", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x140019f6c", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 1" + }, + { + "address": "0x140019f71", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x140019f76", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x140019f7a", + "size": 5, + "mnemonic": "call", + "operands": "0x140015e88" + }, + { + "address": "0x140019f7f", + "size": 2, + "mnemonic": "or", + "operands": "esi, eax" + }, + { + "address": "0x140019f81", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x140019f85", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rdi + 0x160]" + }, + { + "address": "0x140019f8c", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, r15d" + }, + { + "address": "0x140019f8f", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x140019f92", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x140019f97", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 2" + }, + { + "address": "0x140019f9c", + "size": 5, + "mnemonic": "call", + "operands": "0x140015e88" + }, + { + "address": "0x140019fa1", + "size": 2, + "mnemonic": "or", + "operands": "esi, eax" + }, + { + "address": "0x140019fa3", + "size": 4, + "mnemonic": "lea", + "operands": "r9d, [r15 - 7]" + }, + { + "address": "0x140019fa7", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rdi + 0x198]" + }, + { + "address": "0x140019fae", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x140019fb1", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 2" + }, + { + "address": "0x140019fb6", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x140019fbb", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x140019fbf", + "size": 5, + "mnemonic": "call", + "operands": "0x140015e88" + }, + { + "address": "0x140019fc4", + "size": 2, + "mnemonic": "or", + "operands": "esi, eax" + }, + { + "address": "0x140019fc6", + "size": 3, + "mnemonic": "inc", + "operands": "r15d" + }, + { + "address": "0x140019fc9", + "size": 4, + "mnemonic": "sub", + "operands": "r13, 1" + }, + { + "address": "0x140019fcd", + "size": 6, + "mnemonic": "jne", + "operands": "0x140019f27" + }, + { + "address": "0x140019fd3", + "size": 4, + "mnemonic": "lea", + "operands": "r15d, [r13 + 0x38]" + }, + { + "address": "0x140019fd7", + "size": 4, + "mnemonic": "lea", + "operands": "r13d, [r15 - 0x2c]" + }, + { + "address": "0x140019fdb", + "size": 8, + "mnemonic": "lea", + "operands": "rdi, [r12 + 0xd0]" + }, + { + "address": "0x140019fe3", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rdi - 0x60]" + }, + { + "address": "0x140019fe7", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x140019fea", + "size": 4, + "mnemonic": "lea", + "operands": "r9d, [r15 + 0xc]" + }, + { + "address": "0x140019fee", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x140019ff3", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 1" + }, + { + "address": "0x140019ff8", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x140019ffc", + "size": 5, + "mnemonic": "call", + "operands": "0x140015e88" + }, + { + "address": "0x14001a001", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, r15d" + }, + { + "address": "0x14001a004", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rdi" + }, + { + "address": "0x14001a009", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x14001a00c", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x14001a010", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 1" + }, + { + "address": "0x14001a015", + "size": 2, + "mnemonic": "or", + "operands": "esi, eax" + }, + { + "address": "0x14001a017", + "size": 5, + "mnemonic": "call", + "operands": "0x140015e88" + }, + { + "address": "0x14001a01c", + "size": 2, + "mnemonic": "or", + "operands": "esi, eax" + }, + { + "address": "0x14001a01e", + "size": 4, + "mnemonic": "lea", + "operands": "r9d, [r15 + 0xc]" + }, + { + "address": "0x14001a022", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rdi + 0x100]" + }, + { + "address": "0x14001a029", + "size": 5, + "mnemonic": "mov", + "operands": "ebx, 2" + }, + { + "address": "0x14001a02e", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x14001a031", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14001a036", + "size": 2, + "mnemonic": "mov", + "operands": "edx, ebx" + }, + { + "address": "0x14001a038", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x14001a03c", + "size": 5, + "mnemonic": "call", + "operands": "0x140015e88" + }, + { + "address": "0x14001a041", + "size": 2, + "mnemonic": "or", + "operands": "esi, eax" + }, + { + "address": "0x14001a043", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x14001a047", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rdi + 0x160]" + }, + { + "address": "0x14001a04e", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, r15d" + }, + { + "address": "0x14001a051", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x14001a054", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14001a059", + "size": 2, + "mnemonic": "mov", + "operands": "edx, ebx" + }, + { + "address": "0x14001a05b", + "size": 5, + "mnemonic": "call", + "operands": "0x140015e88" + }, + { + "address": "0x14001a060", + "size": 2, + "mnemonic": "or", + "operands": "esi, eax" + }, + { + "address": "0x14001a062", + "size": 4, + "mnemonic": "add", + "operands": "rdi, 8" + }, + { + "address": "0x14001a066", + "size": 3, + "mnemonic": "inc", + "operands": "r15d" + }, + { + "address": "0x14001a069", + "size": 4, + "mnemonic": "sub", + "operands": "r13, 1" + }, + { + "address": "0x14001a06d", + "size": 6, + "mnemonic": "jne", + "operands": "0x140019fe3" + }, + { + "address": "0x14001a073", + "size": 8, + "mnemonic": "lea", + "operands": "rax, [r12 + 0x130]" + }, + { + "address": "0x14001a07b", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x14001a07e", + "size": 3, + "mnemonic": "lea", + "operands": "edi, [rbx + 0x26]" + }, + { + "address": "0x14001a081", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14001a086", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, edi" + }, + { + "address": "0x14001a089", + "size": 3, + "mnemonic": "lea", + "operands": "edx, [rbx - 1]" + }, + { + "address": "0x14001a08c", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x14001a090", + "size": 5, + "mnemonic": "call", + "operands": "0x140015e88" + }, + { + "address": "0x14001a095", + "size": 2, + "mnemonic": "or", + "operands": "esi, eax" + }, + { + "address": "0x14001a097", + "size": 3, + "mnemonic": "lea", + "operands": "ebx, [rdi + 1]" + }, + { + "address": "0x14001a09a", + "size": 8, + "mnemonic": "lea", + "operands": "rax, [r12 + 0x138]" + }, + { + "address": "0x14001a0a2", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, ebx" + }, + { + "address": "0x14001a0a5", + "size": 4, + "mnemonic": "lea", + "operands": "r13d, [rdi - 0x27]" + }, + { + "address": "0x14001a0a9", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14001a0ae", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x14001a0b1", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x14001a0b5", + "size": 3, + "mnemonic": "mov", + "operands": "edx, r13d" + }, + { + "address": "0x14001a0b8", + "size": 5, + "mnemonic": "call", + "operands": "0x140015e88" + }, + { + "address": "0x14001a0bd", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, edi" + }, + { + "address": "0x14001a0c0", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x14001a0c4", + "size": 2, + "mnemonic": "or", + "operands": "esi, eax" + }, + { + "address": "0x14001a0c6", + "size": 3, + "mnemonic": "lea", + "operands": "edi, [rbx - 0x27]" + }, + { + "address": "0x14001a0c9", + "size": 8, + "mnemonic": "lea", + "operands": "rax, [r12 + 0x290]" + }, + { + "address": "0x14001a0d1", + "size": 2, + "mnemonic": "mov", + "operands": "edx, edi" + }, + { + "address": "0x14001a0d3", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x14001a0d6", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14001a0db", + "size": 5, + "mnemonic": "call", + "operands": "0x140015e88" + }, + { + "address": "0x14001a0e0", + "size": 2, + "mnemonic": "or", + "operands": "esi, eax" + }, + { + "address": "0x14001a0e2", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x14001a0e6", + "size": 8, + "mnemonic": "lea", + "operands": "rax, [r12 + 0x298]" + }, + { + "address": "0x14001a0ee", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, ebx" + }, + { + "address": "0x14001a0f1", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x14001a0f4", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14001a0f9", + "size": 2, + "mnemonic": "mov", + "operands": "edx, edi" + }, + { + "address": "0x14001a0fb", + "size": 5, + "mnemonic": "call", + "operands": "0x140015e88" + }, + { + "address": "0x14001a100", + "size": 2, + "mnemonic": "or", + "operands": "esi, eax" + }, + { + "address": "0x14001a102", + "size": 4, + "mnemonic": "lea", + "operands": "r15d, [rbx - 0xa]" + }, + { + "address": "0x14001a106", + "size": 8, + "mnemonic": "lea", + "operands": "rax, [r12 + 0x140]" + }, + { + "address": "0x14001a10e", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, r15d" + }, + { + "address": "0x14001a111", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x14001a114", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14001a119", + "size": 3, + "mnemonic": "mov", + "operands": "edx, r13d" + }, + { + "address": "0x14001a11c", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x14001a120", + "size": 5, + "mnemonic": "call", + "operands": "0x140015e88" + }, + { + "address": "0x14001a125", + "size": 2, + "mnemonic": "or", + "operands": "esi, eax" + }, + { + "address": "0x14001a127", + "size": 3, + "mnemonic": "lea", + "operands": "edi, [rbx - 9]" + }, + { + "address": "0x14001a12a", + "size": 8, + "mnemonic": "lea", + "operands": "rax, [r12 + 0x148]" + }, + { + "address": "0x14001a132", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, edi" + }, + { + "address": "0x14001a135", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x14001a138", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14001a13d", + "size": 3, + "mnemonic": "mov", + "operands": "edx, r13d" + }, + { + "address": "0x14001a140", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x14001a144", + "size": 5, + "mnemonic": "call", + "operands": "0x140015e88" + }, + { + "address": "0x14001a149", + "size": 2, + "mnemonic": "or", + "operands": "esi, eax" + }, + { + "address": "0x14001a14b", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x14001a14f", + "size": 8, + "mnemonic": "lea", + "operands": "rax, [r12 + 0x150]" + }, + { + "address": "0x14001a157", + "size": 5, + "mnemonic": "mov", + "operands": "ebx, 0x1003" + }, + { + "address": "0x14001a15c", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, ebx" + }, + { + "address": "0x14001a15f", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14001a164", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x14001a167", + "size": 3, + "mnemonic": "mov", + "operands": "edx, r13d" + }, + { + "address": "0x14001a16a", + "size": 5, + "mnemonic": "call", + "operands": "0x140015e88" + }, + { + "address": "0x14001a16f", + "size": 2, + "mnemonic": "or", + "operands": "esi, eax" + }, + { + "address": "0x14001a171", + "size": 4, + "mnemonic": "lea", + "operands": "r9d, [rbx + 6]" + }, + { + "address": "0x14001a175", + "size": 8, + "mnemonic": "lea", + "operands": "rax, [r12 + 0x158]" + }, + { + "address": "0x14001a17d", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x14001a180", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14001a182", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14001a187", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x14001a18b", + "size": 5, + "mnemonic": "call", + "operands": "0x140015e88" + }, + { + "address": "0x14001a190", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, r15d" + }, + { + "address": "0x14001a193", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x14001a197", + "size": 2, + "mnemonic": "or", + "operands": "esi, eax" + }, + { + "address": "0x14001a199", + "size": 4, + "mnemonic": "lea", + "operands": "r15d, [r13 + 1]" + }, + { + "address": "0x14001a19d", + "size": 8, + "mnemonic": "lea", + "operands": "rax, [r12 + 0x2a0]" + }, + { + "address": "0x14001a1a5", + "size": 3, + "mnemonic": "mov", + "operands": "edx, r15d" + }, + { + "address": "0x14001a1a8", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x14001a1ab", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14001a1b0", + "size": 5, + "mnemonic": "call", + "operands": "0x140015e88" + }, + { + "address": "0x14001a1b5", + "size": 2, + "mnemonic": "or", + "operands": "esi, eax" + }, + { + "address": "0x14001a1b7", + "size": 8, + "mnemonic": "lea", + "operands": "rax, [r12 + 0x2a8]" + }, + { + "address": "0x14001a1bf", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, edi" + }, + { + "address": "0x14001a1c2", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14001a1c7", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x14001a1ca", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x14001a1ce", + "size": 3, + "mnemonic": "mov", + "operands": "edx, r15d" + }, + { + "address": "0x14001a1d1", + "size": 5, + "mnemonic": "call", + "operands": "0x140015e88" + }, + { + "address": "0x14001a1d6", + "size": 2, + "mnemonic": "or", + "operands": "esi, eax" + }, + { + "address": "0x14001a1d8", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x10]" + }, + { + "address": "0x14001a1dc", + "size": 8, + "mnemonic": "lea", + "operands": "rax, [r12 + 0x2b0]" + }, + { + "address": "0x14001a1e4", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, ebx" + }, + { + "address": "0x14001a1e7", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x14001a1ea", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14001a1ef", + "size": 3, + "mnemonic": "mov", + "operands": "edx, r15d" + }, + { + "address": "0x14001a1f2", + "size": 5, + "mnemonic": "call", + "operands": "0x140015e88" + }, + { + "address": "0x14001a1f7", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x40]" + }, + { + "address": "0x14001a1fc", + "size": 2, + "mnemonic": "or", + "operands": "eax, esi" + }, + { + "address": "0x14001a1fe", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x30]" + }, + { + "address": "0x14001a202", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x38]" + }, + { + "address": "0x14001a206", + "size": 3, + "mnemonic": "sete", + "operands": "al" + }, + { + "address": "0x14001a209", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x40]" + }, + { + "address": "0x14001a20d", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x14001a210", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14001a212", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001a214", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14001a216", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14001a218", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001a219", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001bbdc", + "name": "", + "blocks": [ + { + "address": "0x14001bbdc", + "size": 30, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bbdc", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001bbde", + "size": 1, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x14001bbdf", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x14001bbe0", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001bbe1", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x14001bbe3", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14001bbe5", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14001bbe7", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14001bbea", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x14001bbee", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x1544b]" + }, + { + "address": "0x14001bbf5", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x14001bbf8", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x10], rax" + }, + { + "address": "0x14001bbfc", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r8" + }, + { + "address": "0x14001bbff", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rdx" + }, + { + "address": "0x14001bc02", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rcx" + }, + { + "address": "0x14001bc05", + "size": 5, + "mnemonic": "call", + "operands": "0x1400118c4" + }, + { + "address": "0x14001bc0a", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rax" + }, + { + "address": "0x14001bc0d", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001bc0f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x20], rax" + }, + { + "address": "0x14001bc13", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x18], eax" + }, + { + "address": "0x14001bc16", + "size": 5, + "mnemonic": "call", + "operands": "0x1400118c4" + }, + { + "address": "0x14001bc1b", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x20]" + }, + { + "address": "0x14001bc1f", + "size": 3, + "mnemonic": "xor", + "operands": "r12d, r12d" + }, + { + "address": "0x14001bc22", + "size": 7, + "mnemonic": "lea", + "operands": "rbx, [rsi + 0xa0]" + }, + { + "address": "0x14001bc29", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x3a0], rcx" + }, + { + "address": "0x14001bc30", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [r14 + 0x80]" + }, + { + "address": "0x14001bc37", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rsi + 0x98], r14" + }, + { + "address": "0x14001bc3e", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rbx], rax" + }, + { + "address": "0x14001bc41", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001bc44", + "size": 2, + "mnemonic": "je", + "operands": "0x14001bc64" + } + ], + "successors": [ + "0x14001bc64", + "0x14001bc46" + ] + }, + { + "address": "0x14001bc64", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bc64", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x20], r12d" + }, + { + "address": "0x14001bc68", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsi + 0x98]" + }, + { + "address": "0x14001bc6f", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001bc72", + "size": 2, + "mnemonic": "je", + "operands": "0x14001bcee" + } + ], + "successors": [ + "0x14001bcee", + "0x14001bc74" + ] + }, + { + "address": "0x14001bc46", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bc46", + "size": 4, + "mnemonic": "cmp", + "operands": "word ptr [rax], r12w" + }, + { + "address": "0x14001bc4a", + "size": 2, + "mnemonic": "je", + "operands": "0x14001bc64" + } + ], + "successors": [ + "0x14001bc64", + "0x14001bc4c" + ] + }, + { + "address": "0x14001bcee", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bcee", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx]" + }, + { + "address": "0x14001bcf1", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001bcf4", + "size": 2, + "mnemonic": "je", + "operands": "0x14001bd47" + } + ], + "successors": [ + "0x14001bd47", + "0x14001bcf6" + ] + }, + { + "address": "0x14001bc74", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bc74", + "size": 4, + "mnemonic": "cmp", + "operands": "word ptr [rax], r12w" + }, + { + "address": "0x14001bc78", + "size": 2, + "mnemonic": "je", + "operands": "0x14001bcee" + } + ], + "successors": [ + "0x14001bcee", + "0x14001bc7a" + ] + }, + { + "address": "0x14001bc4c", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bc4c", + "size": 7, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rip + 0xb3ed]" + }, + { + "address": "0x14001bc53", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0xb276]" + }, + { + "address": "0x14001bc5a", + "size": 2, + "mnemonic": "dec", + "operands": "edx" + }, + { + "address": "0x14001bc5c", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rbx" + }, + { + "address": "0x14001bc5f", + "size": 5, + "mnemonic": "call", + "operands": "0x14001bb54" + }, + { + "address": "0x14001bc64", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x20], r12d" + }, + { + "address": "0x14001bc68", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsi + 0x98]" + }, + { + "address": "0x14001bc6f", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001bc72", + "size": 2, + "mnemonic": "je", + "operands": "0x14001bcee" + } + ], + "successors": [ + "0x14001bcee", + "0x14001bc74" + ] + }, + { + "address": "0x14001bd47", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bd47", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x20], 0x104" + }, + { + "address": "0x14001bd4e", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x4484]" + }, + { + "address": "0x14001bd54", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x18], eax" + }, + { + "address": "0x14001bd57", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x1c], eax" + }, + { + "address": "0x14001bd5a", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rbp - 0x20], r12d" + }, + { + "address": "0x14001bd5e", + "size": 6, + "mnemonic": "je", + "operands": "0x14001be3f" + } + ], + "successors": [ + "0x14001be3f", + "0x14001bd64" + ] + }, + { + "address": "0x14001bcf6", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bcf6", + "size": 4, + "mnemonic": "cmp", + "operands": "word ptr [rax], r12w" + }, + { + "address": "0x14001bcfa", + "size": 2, + "mnemonic": "je", + "operands": "0x14001bd47" + } + ], + "successors": [ + "0x14001bd47", + "0x14001bcfc" + ] + }, + { + "address": "0x14001bc7a", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bc7a", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx]" + }, + { + "address": "0x14001bc7d", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001bc80", + "size": 2, + "mnemonic": "je", + "operands": "0x14001bc93" + } + ], + "successors": [ + "0x14001bc93", + "0x14001bc82" + ] + }, + { + "address": "0x14001be3f", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001be3f", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001be41", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x10]" + }, + { + "address": "0x14001be45", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x14001be48", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x14001be4d", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x40" + }, + { + "address": "0x14001be51", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14001be53", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001be55", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14001be57", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001be58", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14001be59", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001be5a", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001be5b", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001bd64", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bd64", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [r14 + 0x100]" + }, + { + "address": "0x14001bd6b", + "size": 3, + "mnemonic": "neg", + "operands": "r14" + }, + { + "address": "0x14001bd6e", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x20]" + }, + { + "address": "0x14001bd72", + "size": 3, + "mnemonic": "sbb", + "operands": "rcx, rcx" + }, + { + "address": "0x14001bd75", + "size": 3, + "mnemonic": "and", + "operands": "rcx, rax" + }, + { + "address": "0x14001bd78", + "size": 5, + "mnemonic": "call", + "operands": "0x14001b9e4" + }, + { + "address": "0x14001bd7d", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, eax" + }, + { + "address": "0x14001bd7f", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001bd81", + "size": 6, + "mnemonic": "je", + "operands": "0x14001be3f" + } + ], + "successors": [ + "0x14001be3f", + "0x14001bd87" + ] + }, + { + "address": "0x14001bcfc", + "size": 18, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bcfc", + "size": 5, + "mnemonic": "call", + "operands": "0x1400118c4" + }, + { + "address": "0x14001bd01", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rax" + }, + { + "address": "0x14001bd04", + "size": 4, + "mnemonic": "or", + "operands": "rcx, 0xffffffffffffffff" + }, + { + "address": "0x14001bd08", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax + 0xa0]" + }, + { + "address": "0x14001bd0f", + "size": 3, + "mnemonic": "inc", + "operands": "rcx" + }, + { + "address": "0x14001bd12", + "size": 5, + "mnemonic": "cmp", + "operands": "word ptr [rax + rcx*2], r12w" + }, + { + "address": "0x14001bd17", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001bd0f" + }, + { + "address": "0x14001bd19", + "size": 4, + "mnemonic": "cmp", + "operands": "rcx, 3" + }, + { + "address": "0x14001bd1d", + "size": 3, + "mnemonic": "mov", + "operands": "eax, r12d" + }, + { + "address": "0x14001bd20", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip - 0x92f]" + }, + { + "address": "0x14001bd27", + "size": 3, + "mnemonic": "sete", + "operands": "al" + }, + { + "address": "0x14001bd2a", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rdx + 0xb4], eax" + }, + { + "address": "0x14001bd30", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 1" + }, + { + "address": "0x14001bd35", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x44a5]" + }, + { + "address": "0x14001bd3b", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [rbp - 0x20], 4" + }, + { + "address": "0x14001bd3f", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001bd5a" + }, + { + "address": "0x14001bd41", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x20], r12d" + }, + { + "address": "0x14001bd45", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001bd5a" + } + ], + "successors": [ + "0x14001bd5a" + ] + }, + { + "address": "0x14001bc93", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bc93", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x20]" + }, + { + "address": "0x14001bc97", + "size": 5, + "mnemonic": "call", + "operands": "0x14001b5b0" + }, + { + "address": "0x14001bc9c", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rbp - 0x20], r12d" + }, + { + "address": "0x14001bca0", + "size": 6, + "mnemonic": "jne", + "operands": "0x14001bd64" + }, + { + "address": "0x14001bca6", + "size": 7, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rip + 0xb213]" + }, + { + "address": "0x14001bcad", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rsi + 0x98]" + }, + { + "address": "0x14001bcb4", + "size": 2, + "mnemonic": "dec", + "operands": "edx" + }, + { + "address": "0x14001bcb6", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0xadf3]" + }, + { + "address": "0x14001bcbd", + "size": 5, + "mnemonic": "call", + "operands": "0x14001bb54" + }, + { + "address": "0x14001bcc2", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x14001bcc4", + "size": 6, + "mnemonic": "je", + "operands": "0x14001bd5a" + } + ], + "successors": [ + "0x14001bd5a", + "0x14001bcca" + ] + }, + { + "address": "0x14001bc82", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bc82", + "size": 4, + "mnemonic": "cmp", + "operands": "word ptr [rax], r12w" + }, + { + "address": "0x14001bc86", + "size": 2, + "mnemonic": "je", + "operands": "0x14001bc93" + } + ], + "successors": [ + "0x14001bc93", + "0x14001bc88" + ] + }, + { + "address": "0x14001bd87", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bd87", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, bx" + }, + { + "address": "0x14001bd8a", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x44c0]" + }, + { + "address": "0x14001bd90", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001bd92", + "size": 6, + "mnemonic": "je", + "operands": "0x14001be3f" + } + ], + "successors": [ + "0x14001be3f", + "0x14001bd98" + ] + }, + { + "address": "0x14001bd5a", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bd5a", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rbp - 0x20], r12d" + }, + { + "address": "0x14001bd5e", + "size": 6, + "mnemonic": "je", + "operands": "0x14001be3f" + } + ], + "successors": [ + "0x14001be3f", + "0x14001bd64" + ] + }, + { + "address": "0x14001bcca", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bcca", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx]" + }, + { + "address": "0x14001bccd", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001bcd0", + "size": 2, + "mnemonic": "je", + "operands": "0x14001bce3" + } + ], + "successors": [ + "0x14001bce3", + "0x14001bcd2" + ] + }, + { + "address": "0x14001bc88", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bc88", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x20]" + }, + { + "address": "0x14001bc8c", + "size": 5, + "mnemonic": "call", + "operands": "0x14001b4e0" + }, + { + "address": "0x14001bc91", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001bc9c" + } + ], + "successors": [ + "0x14001bc9c" + ] + }, + { + "address": "0x14001bd98", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bd98", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbp - 0x1c]" + }, + { + "address": "0x14001bd9b", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 1" + }, + { + "address": "0x14001bda0", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x442a]" + }, + { + "address": "0x14001bda6", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001bda8", + "size": 6, + "mnemonic": "je", + "operands": "0x14001be3f" + } + ], + "successors": [ + "0x14001be3f", + "0x14001bdae" + ] + }, + { + "address": "0x14001bce3", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bce3", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x20]" + }, + { + "address": "0x14001bce7", + "size": 5, + "mnemonic": "call", + "operands": "0x14001b5b0" + }, + { + "address": "0x14001bcec", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001bd5a" + } + ], + "successors": [ + "0x14001bd5a" + ] + }, + { + "address": "0x14001bcd2", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bcd2", + "size": 4, + "mnemonic": "cmp", + "operands": "word ptr [rax], r12w" + }, + { + "address": "0x14001bcd6", + "size": 2, + "mnemonic": "je", + "operands": "0x14001bce3" + } + ], + "successors": [ + "0x14001bce3", + "0x14001bcd8" + ] + }, + { + "address": "0x14001bc9c", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bc9c", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rbp - 0x20], r12d" + }, + { + "address": "0x14001bca0", + "size": 6, + "mnemonic": "jne", + "operands": "0x14001bd64" + }, + { + "address": "0x14001bca6", + "size": 7, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rip + 0xb213]" + }, + { + "address": "0x14001bcad", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rsi + 0x98]" + }, + { + "address": "0x14001bcb4", + "size": 2, + "mnemonic": "dec", + "operands": "edx" + }, + { + "address": "0x14001bcb6", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0xadf3]" + }, + { + "address": "0x14001bcbd", + "size": 5, + "mnemonic": "call", + "operands": "0x14001bb54" + }, + { + "address": "0x14001bcc2", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x14001bcc4", + "size": 6, + "mnemonic": "je", + "operands": "0x14001bd5a" + } + ], + "successors": [ + "0x14001bd5a", + "0x14001bcca" + ] + }, + { + "address": "0x14001bdae", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bdae", + "size": 3, + "mnemonic": "test", + "operands": "r15, r15" + }, + { + "address": "0x14001bdb1", + "size": 2, + "mnemonic": "je", + "operands": "0x14001bdb6" + } + ], + "successors": [ + "0x14001bdb6", + "0x14001bdb3" + ] + }, + { + "address": "0x14001bcd8", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bcd8", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x20]" + }, + { + "address": "0x14001bcdc", + "size": 5, + "mnemonic": "call", + "operands": "0x14001b4e0" + }, + { + "address": "0x14001bce1", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001bd5a" + } + ], + "successors": [ + "0x14001bd5a" + ] + }, + { + "address": "0x14001bdb6", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bdb6", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbp - 0x1c]" + }, + { + "address": "0x14001bdb9", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rsi + 0x2f0]" + }, + { + "address": "0x14001bdc0", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x14001bdc3", + "size": 4, + "mnemonic": "lea", + "operands": "esi, [r9 + 0x55]" + }, + { + "address": "0x14001bdc7", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, esi" + }, + { + "address": "0x14001bdca", + "size": 5, + "mnemonic": "call", + "operands": "0x140012164" + }, + { + "address": "0x14001bdcf", + "size": 3, + "mnemonic": "test", + "operands": "rdi, rdi" + }, + { + "address": "0x14001bdd2", + "size": 2, + "mnemonic": "je", + "operands": "0x14001be38" + } + ], + "successors": [ + "0x14001be38", + "0x14001bdd4" + ] + }, + { + "address": "0x14001bdb3", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bdb3", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [r15], ebx" + }, + { + "address": "0x14001bdb6", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbp - 0x1c]" + }, + { + "address": "0x14001bdb9", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rsi + 0x2f0]" + }, + { + "address": "0x14001bdc0", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x14001bdc3", + "size": 4, + "mnemonic": "lea", + "operands": "esi, [r9 + 0x55]" + }, + { + "address": "0x14001bdc7", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, esi" + }, + { + "address": "0x14001bdca", + "size": 5, + "mnemonic": "call", + "operands": "0x140012164" + }, + { + "address": "0x14001bdcf", + "size": 3, + "mnemonic": "test", + "operands": "rdi, rdi" + }, + { + "address": "0x14001bdd2", + "size": 2, + "mnemonic": "je", + "operands": "0x14001be38" + } + ], + "successors": [ + "0x14001be38", + "0x14001bdd4" + ] + }, + { + "address": "0x14001be38", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001be38", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 1" + }, + { + "address": "0x14001be3d", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001be41" + } + ], + "successors": [ + "0x14001be41" + ] + }, + { + "address": "0x14001bdd4", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bdd4", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbp - 0x1c]" + }, + { + "address": "0x14001bdd7", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rdi + 0x120]" + }, + { + "address": "0x14001bdde", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x14001bde1", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, esi" + }, + { + "address": "0x14001bde4", + "size": 5, + "mnemonic": "call", + "operands": "0x140012164" + }, + { + "address": "0x14001bde9", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbp - 0x1c]" + }, + { + "address": "0x14001bdec", + "size": 5, + "mnemonic": "mov", + "operands": "esi, 0x40" + }, + { + "address": "0x14001bdf1", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, esi" + }, + { + "address": "0x14001bdf4", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rdi" + }, + { + "address": "0x14001bdf7", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0x1001" + }, + { + "address": "0x14001bdfc", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x43c6]" + }, + { + "address": "0x14001be02", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001be04", + "size": 2, + "mnemonic": "je", + "operands": "0x14001be3f" + } + ], + "successors": [ + "0x14001be3f", + "0x14001be06" + ] + }, + { + "address": "0x14001be41", + "size": 12, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001be41", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x10]" + }, + { + "address": "0x14001be45", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x14001be48", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x14001be4d", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x40" + }, + { + "address": "0x14001be51", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14001be53", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001be55", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14001be57", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001be58", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14001be59", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001be5a", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001be5b", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001be06", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001be06", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbp - 0x18]" + }, + { + "address": "0x14001be09", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rdi + 0x80]" + }, + { + "address": "0x14001be10", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, esi" + }, + { + "address": "0x14001be13", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0x1002" + }, + { + "address": "0x14001be18", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x43aa]" + }, + { + "address": "0x14001be1e", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001be20", + "size": 2, + "mnemonic": "je", + "operands": "0x14001be3f" + } + ], + "successors": [ + "0x14001be3f", + "0x14001be22" + ] + }, + { + "address": "0x14001be22", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001be22", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rdi + 0x100]" + }, + { + "address": "0x14001be29", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x14001be2b", + "size": 4, + "mnemonic": "lea", + "operands": "r9d, [rsi - 0x36]" + }, + { + "address": "0x14001be2f", + "size": 4, + "mnemonic": "lea", + "operands": "r8d, [rsi - 0x30]" + }, + { + "address": "0x14001be33", + "size": 5, + "mnemonic": "call", + "operands": "0x14001d3e4" + }, + { + "address": "0x14001be38", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 1" + }, + { + "address": "0x14001be3d", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001be41" + } + ], + "successors": [ + "0x14001be41" + ] + } + ] + }, + { + "address": "0x14001c269", + "name": "", + "blocks": [ + { + "address": "0x14001c269", + "size": 21, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c269", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001c26a", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x14001c26b", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001c26c", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x14001c26e", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x14001c270", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14001c272", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14001c274", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x14001c278", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x14dc1]" + }, + { + "address": "0x14001c27f", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x14001c282", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], rax" + }, + { + "address": "0x14001c287", + "size": 8, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0xa0]" + }, + { + "address": "0x14001c28f", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, r9" + }, + { + "address": "0x14001c292", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rdx]" + }, + { + "address": "0x14001c295", + "size": 3, + "mnemonic": "mov", + "operands": "r15, r8" + }, + { + "address": "0x14001c298", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14001c29d", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rdx" + }, + { + "address": "0x14001c2a0", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], r9" + }, + { + "address": "0x14001c2a5", + "size": 3, + "mnemonic": "mov", + "operands": "r12, rcx" + }, + { + "address": "0x14001c2a8", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001c2ab", + "size": 6, + "mnemonic": "je", + "operands": "0x14001c33e" + } + ], + "successors": [ + "0x14001c33e", + "0x14001c2b1" + ] + }, + { + "address": "0x14001c33e", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c33e", + "size": 3, + "mnemonic": "movzx", + "operands": "edx, word ptr [rdi]" + }, + { + "address": "0x14001c341", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x30]" + }, + { + "address": "0x14001c346", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rax" + }, + { + "address": "0x14001c349", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rsi" + }, + { + "address": "0x14001c34c", + "size": 2, + "mnemonic": "xor", + "operands": "ebx, ebx" + }, + { + "address": "0x14001c34e", + "size": 5, + "mnemonic": "call", + "operands": "0x140016d88" + }, + { + "address": "0x14001c353", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, -1" + }, + { + "address": "0x14001c357", + "size": 2, + "mnemonic": "je", + "operands": "0x14001c392" + } + ], + "successors": [ + "0x14001c392", + "0x14001c359" + ] + }, + { + "address": "0x14001c2b1", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c2b1", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14001c2b4", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdi" + }, + { + "address": "0x14001c2b7", + "size": 3, + "mnemonic": "movzx", + "operands": "edx, word ptr [rdi]" + }, + { + "address": "0x14001c2ba", + "size": 5, + "mnemonic": "lea", + "operands": "r13, [rsp + 0x30]" + }, + { + "address": "0x14001c2bf", + "size": 4, + "mnemonic": "cmp", + "operands": "r15, 4" + }, + { + "address": "0x14001c2c3", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rax" + }, + { + "address": "0x14001c2c6", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rsi" + }, + { + "address": "0x14001c2c9", + "size": 4, + "mnemonic": "cmovae", + "operands": "r13, rbx" + }, + { + "address": "0x14001c2cd", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r13" + }, + { + "address": "0x14001c2d0", + "size": 5, + "mnemonic": "call", + "operands": "0x140016d88" + }, + { + "address": "0x14001c2d5", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rax" + }, + { + "address": "0x14001c2d8", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, -1" + }, + { + "address": "0x14001c2dc", + "size": 2, + "mnemonic": "je", + "operands": "0x14001c335" + } + ], + "successors": [ + "0x14001c335", + "0x14001c2de" + ] + }, + { + "address": "0x14001c392", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001c392", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14001c397", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x14001c39a", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x14001c39f", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x90]" + }, + { + "address": "0x14001c3a7", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x40" + }, + { + "address": "0x14001c3ab", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14001c3ad", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001c3af", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14001c3b1", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14001c3b3", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001c3b4", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14001c3b5", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001c3b6", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001c359", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c359", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x20]" + }, + { + "address": "0x14001c35e", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001c361", + "size": 2, + "mnemonic": "je", + "operands": "0x14001c36a" + } + ], + "successors": [ + "0x14001c36a", + "0x14001c363" + ] + }, + { + "address": "0x14001c335", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c335", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [r14], rbp" + }, + { + "address": "0x14001c338", + "size": 4, + "mnemonic": "or", + "operands": "rax, 0xffffffffffffffff" + }, + { + "address": "0x14001c33c", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001c392" + } + ], + "successors": [ + "0x14001c392" + ] + }, + { + "address": "0x14001c2de", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c2de", + "size": 3, + "mnemonic": "cmp", + "operands": "r13, rbx" + }, + { + "address": "0x14001c2e1", + "size": 2, + "mnemonic": "je", + "operands": "0x14001c2f6" + } + ], + "successors": [ + "0x14001c2f6", + "0x14001c2e3" + ] + }, + { + "address": "0x14001c36a", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c36a", + "size": 4, + "mnemonic": "add", + "operands": "rdi, 2" + }, + { + "address": "0x14001c36e", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x30]" + }, + { + "address": "0x14001c373", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rbp" + }, + { + "address": "0x14001c376", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rsi" + }, + { + "address": "0x14001c379", + "size": 3, + "mnemonic": "add", + "operands": "rbx, rax" + }, + { + "address": "0x14001c37c", + "size": 3, + "mnemonic": "movzx", + "operands": "edx, word ptr [rdi]" + }, + { + "address": "0x14001c37f", + "size": 5, + "mnemonic": "call", + "operands": "0x140016d88" + }, + { + "address": "0x14001c384", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, -1" + }, + { + "address": "0x14001c388", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001c35e" + }, + { + "address": "0x14001c38a", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001c392" + } + ], + "successors": [ + "0x14001c392" + ] + }, + { + "address": "0x14001c363", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c363", + "size": 5, + "mnemonic": "cmp", + "operands": "byte ptr [rsp + rax + 0x2f], 0" + }, + { + "address": "0x14001c368", + "size": 2, + "mnemonic": "je", + "operands": "0x14001c38c" + } + ], + "successors": [ + "0x14001c38c", + "0x14001c36a" + ] + }, + { + "address": "0x14001c2f6", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c2f6", + "size": 3, + "mnemonic": "test", + "operands": "rsi, rsi" + }, + { + "address": "0x14001c2f9", + "size": 2, + "mnemonic": "je", + "operands": "0x14001c30e" + } + ], + "successors": [ + "0x14001c30e", + "0x14001c2fb" + ] + }, + { + "address": "0x14001c2e3", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c2e3", + "size": 3, + "mnemonic": "cmp", + "operands": "r15, rax" + }, + { + "address": "0x14001c2e6", + "size": 2, + "mnemonic": "jb", + "operands": "0x14001c32a" + } + ], + "successors": [ + "0x14001c32a", + "0x14001c2e8" + ] + }, + { + "address": "0x14001c38c", + "size": 15, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001c38c", + "size": 3, + "mnemonic": "dec", + "operands": "rax" + }, + { + "address": "0x14001c38f", + "size": 3, + "mnemonic": "add", + "operands": "rax, rbx" + }, + { + "address": "0x14001c392", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14001c397", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x14001c39a", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x14001c39f", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x90]" + }, + { + "address": "0x14001c3a7", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x40" + }, + { + "address": "0x14001c3ab", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14001c3ad", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001c3af", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14001c3b1", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14001c3b3", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001c3b4", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14001c3b5", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001c3b6", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001c30e", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c30e", + "size": 4, + "mnemonic": "add", + "operands": "rdi, 2" + }, + { + "address": "0x14001c312", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x20]" + }, + { + "address": "0x14001c317", + "size": 3, + "mnemonic": "sub", + "operands": "r15, rsi" + }, + { + "address": "0x14001c31a", + "size": 3, + "mnemonic": "add", + "operands": "rbx, rsi" + }, + { + "address": "0x14001c31d", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x28]" + }, + { + "address": "0x14001c322", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001c2b7" + } + ], + "successors": [ + "0x14001c2b7" + ] + }, + { + "address": "0x14001c2fb", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c2fb", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rsi + rbx]" + }, + { + "address": "0x14001c2ff", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rax - 1], 0" + }, + { + "address": "0x14001c303", + "size": 2, + "mnemonic": "je", + "operands": "0x14001c324" + } + ], + "successors": [ + "0x14001c324", + "0x14001c305" + ] + }, + { + "address": "0x14001c32a", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c32a", + "size": 3, + "mnemonic": "sub", + "operands": "rbx, r12" + }, + { + "address": "0x14001c32d", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [r14], rbp" + }, + { + "address": "0x14001c330", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x14001c333", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001c392" + } + ], + "successors": [ + "0x14001c392" + ] + }, + { + "address": "0x14001c2e8", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c2e8", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rax" + }, + { + "address": "0x14001c2eb", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r13" + }, + { + "address": "0x14001c2ee", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x14001c2f1", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3e0" + }, + { + "address": "0x14001c2f6", + "size": 3, + "mnemonic": "test", + "operands": "rsi, rsi" + }, + { + "address": "0x14001c2f9", + "size": 2, + "mnemonic": "je", + "operands": "0x14001c30e" + } + ], + "successors": [ + "0x14001c30e", + "0x14001c2fb" + ] + }, + { + "address": "0x14001c2b7", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c2b7", + "size": 3, + "mnemonic": "movzx", + "operands": "edx, word ptr [rdi]" + }, + { + "address": "0x14001c2ba", + "size": 5, + "mnemonic": "lea", + "operands": "r13, [rsp + 0x30]" + }, + { + "address": "0x14001c2bf", + "size": 4, + "mnemonic": "cmp", + "operands": "r15, 4" + }, + { + "address": "0x14001c2c3", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rax" + }, + { + "address": "0x14001c2c6", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rsi" + }, + { + "address": "0x14001c2c9", + "size": 4, + "mnemonic": "cmovae", + "operands": "r13, rbx" + }, + { + "address": "0x14001c2cd", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r13" + }, + { + "address": "0x14001c2d0", + "size": 5, + "mnemonic": "call", + "operands": "0x140016d88" + }, + { + "address": "0x14001c2d5", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rax" + }, + { + "address": "0x14001c2d8", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, -1" + }, + { + "address": "0x14001c2dc", + "size": 2, + "mnemonic": "je", + "operands": "0x14001c335" + } + ], + "successors": [ + "0x14001c335", + "0x14001c2de" + ] + }, + { + "address": "0x14001c324", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c324", + "size": 2, + "mnemonic": "xor", + "operands": "ebp, ebp" + }, + { + "address": "0x14001c326", + "size": 4, + "mnemonic": "lea", + "operands": "rbx, [rax - 1]" + }, + { + "address": "0x14001c32a", + "size": 3, + "mnemonic": "sub", + "operands": "rbx, r12" + }, + { + "address": "0x14001c32d", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [r14], rbp" + }, + { + "address": "0x14001c330", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x14001c333", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001c392" + } + ], + "successors": [ + "0x14001c392" + ] + }, + { + "address": "0x14001c305", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c305", + "size": 4, + "mnemonic": "add", + "operands": "rdi, 2" + }, + { + "address": "0x14001c309", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdi" + }, + { + "address": "0x14001c30c", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001c312" + } + ], + "successors": [ + "0x14001c312" + ] + }, + { + "address": "0x14001c312", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c312", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x20]" + }, + { + "address": "0x14001c317", + "size": 3, + "mnemonic": "sub", + "operands": "r15, rsi" + }, + { + "address": "0x14001c31a", + "size": 3, + "mnemonic": "add", + "operands": "rbx, rsi" + }, + { + "address": "0x14001c31d", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x28]" + }, + { + "address": "0x14001c322", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001c2b7" + } + ], + "successors": [ + "0x14001c2b7" + ] + } + ] + }, + { + "address": "0x14001c5be", + "name": "", + "blocks": [ + { + "address": "0x14001c5be", + "size": 6, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c5be", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001c5bf", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14001c5c2", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x50" + }, + { + "address": "0x14001c5c6", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0xffff" + }, + { + "address": "0x14001c5cb", + "size": 3, + "mnemonic": "cmp", + "operands": "cx, ax" + }, + { + "address": "0x14001c5ce", + "size": 6, + "mnemonic": "je", + "operands": "0x14001c6a3" + } + ], + "successors": [ + "0x14001c6a3", + "0x14001c5d4" + ] + }, + { + "address": "0x14001c6a3", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001c6a3", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x68]" + }, + { + "address": "0x14001c6a8", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x50" + }, + { + "address": "0x14001c6ac", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001c6ad", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001c5d4", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c5d4", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x20]" + }, + { + "address": "0x14001c5d8", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d89c" + }, + { + "address": "0x14001c5dd", + "size": 4, + "mnemonic": "mov", + "operands": "r10, qword ptr [rbp - 0x18]" + }, + { + "address": "0x14001c5e1", + "size": 2, + "mnemonic": "xor", + "operands": "ebx, ebx" + }, + { + "address": "0x14001c5e3", + "size": 6, + "mnemonic": "mov", + "operands": "r11d, 0x100" + }, + { + "address": "0x14001c5e9", + "size": 8, + "mnemonic": "cmp", + "operands": "dword ptr [r10 + 0xc], 0xfde9" + }, + { + "address": "0x14001c5f1", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001c61c" + }, + { + "address": "0x14001c5f3", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, word ptr [rbp + 0x10]" + }, + { + "address": "0x14001c5f7", + "size": 4, + "mnemonic": "lea", + "operands": "eax, [r11 - 0x80]" + }, + { + "address": "0x14001c5fb", + "size": 3, + "mnemonic": "cmp", + "operands": "cx, ax" + }, + { + "address": "0x14001c5fe", + "size": 2, + "mnemonic": "jae", + "operands": "0x14001c656" + }, + { + "address": "0x14001c600", + "size": 3, + "mnemonic": "movzx", + "operands": "eax, cl" + }, + { + "address": "0x14001c603", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip + 0x8e26]" + }, + { + "address": "0x14001c60a", + "size": 6, + "mnemonic": "test", + "operands": "byte ptr [r8 + rax*2 + 2], 1" + }, + { + "address": "0x14001c610", + "size": 2, + "mnemonic": "je", + "operands": "0x14001c617" + } + ], + "successors": [ + "0x14001c617", + "0x14001c612" + ] + }, + { + "address": "0x14001c617", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c617", + "size": 3, + "mnemonic": "movzx", + "operands": "edx, cl" + }, + { + "address": "0x14001c61a", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001c690" + } + ], + "successors": [ + "0x14001c690" + ] + }, + { + "address": "0x14001c612", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c612", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, cl" + }, + { + "address": "0x14001c615", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001c63b" + } + ], + "successors": [ + "0x14001c63b" + ] + }, + { + "address": "0x14001c690", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c690", + "size": 3, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 8], bl" + }, + { + "address": "0x14001c693", + "size": 2, + "mnemonic": "je", + "operands": "0x14001c6a0" + } + ], + "successors": [ + "0x14001c6a0", + "0x14001c695" + ] + }, + { + "address": "0x14001c63b", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c63b", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [r10 + 0x110]" + }, + { + "address": "0x14001c642", + "size": 4, + "mnemonic": "movzx", + "operands": "edx, byte ptr [rax + rcx]" + }, + { + "address": "0x14001c646", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001c690" + } + ], + "successors": [ + "0x14001c690" + ] + }, + { + "address": "0x14001c6a0", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001c6a0", + "size": 3, + "mnemonic": "movzx", + "operands": "eax, dx" + }, + { + "address": "0x14001c6a3", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x68]" + }, + { + "address": "0x14001c6a8", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x50" + }, + { + "address": "0x14001c6ac", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001c6ad", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001c695", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001c695", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp - 0x20]" + }, + { + "address": "0x14001c699", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rcx + 0x3a8], 0xfffffffd" + }, + { + "address": "0x14001c6a0", + "size": 3, + "mnemonic": "movzx", + "operands": "eax, dx" + }, + { + "address": "0x14001c6a3", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x68]" + }, + { + "address": "0x14001c6a8", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x50" + }, + { + "address": "0x14001c6ac", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001c6ad", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001cf6f", + "name": "", + "blocks": [ + { + "address": "0x14001cf6f", + "size": 10, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001cf6f", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001cf70", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14001cf73", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x14001cf77", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x16272], 0" + }, + { + "address": "0x14001cf7e", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r8" + }, + { + "address": "0x14001cf81", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rdx" + }, + { + "address": "0x14001cf84", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rcx" + }, + { + "address": "0x14001cf87", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001cf93" + }, + { + "address": "0x14001cf89", + "size": 5, + "mnemonic": "call", + "operands": "0x14001d930" + }, + { + "address": "0x14001cf8e", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14001d0ec" + } + ], + "successors": [ + "0x14001d0ec" + ] + }, + { + "address": "0x14001d0ec", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001d0ec", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x60]" + }, + { + "address": "0x14001d0f1", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x18]" + }, + { + "address": "0x14001d0f5", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x20]" + }, + { + "address": "0x14001d0f9", + "size": 4, + "mnemonic": "mov", + "operands": "r14, qword ptr [r11 + 0x28]" + }, + { + "address": "0x14001d0fd", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x14001d100", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001d101", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001d113", + "name": "", + "blocks": [ + { + "address": "0x14001d113", + "size": 30, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001d113", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001d114", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14001d116", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14001d118", + "size": 4, + "mnemonic": "lea", + "operands": "rbp, [rax - 0x5f]" + }, + { + "address": "0x14001d11c", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0xa0" + }, + { + "address": "0x14001d123", + "size": 3, + "mnemonic": "xor", + "operands": "r15d, r15d" + }, + { + "address": "0x14001d126", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rdx" + }, + { + "address": "0x14001d129", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rcx" + }, + { + "address": "0x14001d12c", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x17], r15" + }, + { + "address": "0x14001d130", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14001d132", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x1f], r15" + }, + { + "address": "0x14001d136", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x39]" + }, + { + "address": "0x14001d13a", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x27], r15" + }, + { + "address": "0x14001d13e", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x2f], r15" + }, + { + "address": "0x14001d142", + "size": 3, + "mnemonic": "mov", + "operands": "edi, r15d" + }, + { + "address": "0x14001d145", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x37], r15" + }, + { + "address": "0x14001d149", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp + 0x3f], r15b" + }, + { + "address": "0x14001d14d", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x19], r15" + }, + { + "address": "0x14001d151", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x11], r15" + }, + { + "address": "0x14001d155", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 9], r15" + }, + { + "address": "0x14001d159", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 1], r15" + }, + { + "address": "0x14001d15d", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 7], r15" + }, + { + "address": "0x14001d161", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp + 0xf], r15b" + }, + { + "address": "0x14001d165", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d89c" + }, + { + "address": "0x14001d16a", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp - 0x31]" + }, + { + "address": "0x14001d16e", + "size": 5, + "mnemonic": "mov", + "operands": "ebx, 0xfde9" + }, + { + "address": "0x14001d173", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rax + 0xc], ebx" + }, + { + "address": "0x14001d176", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001d18e" + }, + { + "address": "0x14001d178", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x21], r15b" + }, + { + "address": "0x14001d17c", + "size": 2, + "mnemonic": "je", + "operands": "0x14001d189" + } + ], + "successors": [ + "0x14001d189", + "0x14001d17e" + ] + }, + { + "address": "0x14001d189", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001d189", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, ebx" + }, + { + "address": "0x14001d18c", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001d1c4" + } + ], + "successors": [ + "0x14001d1c4" + ] + }, + { + "address": "0x14001d17e", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001d17e", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp - 0x39]" + }, + { + "address": "0x14001d182", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rax + 0x3a8], 0xfffffffd" + }, + { + "address": "0x14001d189", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, ebx" + }, + { + "address": "0x14001d18c", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001d1c4" + } + ], + "successors": [ + "0x14001d1c4" + ] + }, + { + "address": "0x14001d1c4", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001d1c4", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbp + 0x77]" + }, + { + "address": "0x14001d1c8", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x14001d1cb", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp + 0x17]" + }, + { + "address": "0x14001d1cf", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d9d8" + }, + { + "address": "0x14001d1d4", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001d1d6", + "size": 6, + "mnemonic": "jne", + "operands": "0x14001d264" + }, + { + "address": "0x14001d1dc", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14001d1de", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp - 0x39]" + }, + { + "address": "0x14001d1e2", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d89c" + }, + { + "address": "0x14001d1e7", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp - 0x31]" + }, + { + "address": "0x14001d1eb", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rax + 0xc], ebx" + }, + { + "address": "0x14001d1ee", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001d203" + }, + { + "address": "0x14001d1f0", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x21], r15b" + }, + { + "address": "0x14001d1f4", + "size": 2, + "mnemonic": "je", + "operands": "0x14001d238" + } + ], + "successors": [ + "0x14001d238", + "0x14001d1f6" + ] + }, + { + "address": "0x14001d238", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001d238", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, ebx" + }, + { + "address": "0x14001d23b", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbp + 0x77]" + }, + { + "address": "0x14001d23f", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x19]" + }, + { + "address": "0x14001d243", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r14" + }, + { + "address": "0x14001d246", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d9d8" + }, + { + "address": "0x14001d24b", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rbp - 9]" + }, + { + "address": "0x14001d24f", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001d251", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001d264" + }, + { + "address": "0x14001d253", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x27]" + }, + { + "address": "0x14001d257", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rdi" + }, + { + "address": "0x14001d25a", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x3018]" + }, + { + "address": "0x14001d260", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, eax" + }, + { + "address": "0x14001d262", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001d267" + } + ], + "successors": [ + "0x14001d267" + ] + }, + { + "address": "0x14001d1f6", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001d1f6", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp - 0x39]" + }, + { + "address": "0x14001d1fa", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rax + 0x3a8], 0xfffffffd" + }, + { + "address": "0x14001d201", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001d238" + } + ], + "successors": [ + "0x14001d238" + ] + }, + { + "address": "0x14001d267", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001d267", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp + 0xf], r15b" + }, + { + "address": "0x14001d26b", + "size": 2, + "mnemonic": "je", + "operands": "0x14001d275" + } + ], + "successors": [ + "0x14001d275", + "0x14001d26d" + ] + }, + { + "address": "0x14001d275", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001d275", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp + 0x3f], r15b" + }, + { + "address": "0x14001d279", + "size": 2, + "mnemonic": "je", + "operands": "0x14001d284" + } + ], + "successors": [ + "0x14001d284", + "0x14001d27b" + ] + }, + { + "address": "0x14001d26d", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001d26d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x14001d270", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001d275", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp + 0x3f], r15b" + }, + { + "address": "0x14001d279", + "size": 2, + "mnemonic": "je", + "operands": "0x14001d284" + } + ], + "successors": [ + "0x14001d284", + "0x14001d27b" + ] + }, + { + "address": "0x14001d284", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001d284", + "size": 8, + "mnemonic": "lea", + "operands": "r11, [rsp + 0xa0]" + }, + { + "address": "0x14001d28c", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ebx" + }, + { + "address": "0x14001d28e", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x20]" + }, + { + "address": "0x14001d292", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x28]" + }, + { + "address": "0x14001d296", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x38]" + }, + { + "address": "0x14001d29a", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x14001d29d", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14001d29f", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001d2a1", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001d2a2", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001d27b", + "size": 12, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001d27b", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x27]" + }, + { + "address": "0x14001d27f", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001d284", + "size": 8, + "mnemonic": "lea", + "operands": "r11, [rsp + 0xa0]" + }, + { + "address": "0x14001d28c", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ebx" + }, + { + "address": "0x14001d28e", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x20]" + }, + { + "address": "0x14001d292", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x28]" + }, + { + "address": "0x14001d296", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x38]" + }, + { + "address": "0x14001d29a", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x14001d29d", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14001d29f", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001d2a1", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001d2a2", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001d4b2", + "name": "", + "blocks": [ + { + "address": "0x14001d4b2", + "size": 17, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001d4b2", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001d4b3", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14001d4b5", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x14001d4b9", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, r8" + }, + { + "address": "0x14001d4bc", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rdx" + }, + { + "address": "0x14001d4bf", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14001d4c2", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001d4c5", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001d4e5" + }, + { + "address": "0x14001d4c7", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x14001d4cc", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0x16" + }, + { + "address": "0x14001d4d2", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afb4" + }, + { + "address": "0x14001d4d7", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x7fffffff" + }, + { + "address": "0x14001d4dc", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x40" + }, + { + "address": "0x14001d4e0", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001d4e2", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001d4e3", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001d4e4", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001db1c", + "name": "", + "blocks": [ + { + "address": "0x14001db1c", + "size": 28, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001db1c", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001db1e", + "size": 1, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x14001db1f", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x14001db20", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001db21", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x14001db23", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x14001db25", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14001db27", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14001db29", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x98" + }, + { + "address": "0x14001db30", + "size": 5, + "mnemonic": "lea", + "operands": "rbp, [rsp + 0x50]" + }, + { + "address": "0x14001db35", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x13504]" + }, + { + "address": "0x14001db3c", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rbp" + }, + { + "address": "0x14001db3f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x30], rax" + }, + { + "address": "0x14001db43", + "size": 7, + "mnemonic": "movsxd", + "operands": "rdi, dword ptr [rbp + 0xb0]" + }, + { + "address": "0x14001db4a", + "size": 3, + "mnemonic": "xor", + "operands": "r13d, r13d" + }, + { + "address": "0x14001db4d", + "size": 7, + "mnemonic": "mov", + "operands": "r12, qword ptr [rbp + 0xb8]" + }, + { + "address": "0x14001db54", + "size": 3, + "mnemonic": "mov", + "operands": "r14, r9" + }, + { + "address": "0x14001db57", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rbp], r8d" + }, + { + "address": "0x14001db5b", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14001db5e", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x10], rdx" + }, + { + "address": "0x14001db62", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 8], r12" + }, + { + "address": "0x14001db66", + "size": 2, + "mnemonic": "test", + "operands": "edi, edi" + }, + { + "address": "0x14001db68", + "size": 2, + "mnemonic": "jle", + "operands": "0x14001db7a" + }, + { + "address": "0x14001db6a", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rdi" + }, + { + "address": "0x14001db6d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r9" + }, + { + "address": "0x14001db70", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d9c0" + }, + { + "address": "0x14001db75", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rax" + }, + { + "address": "0x14001db78", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001db83" + } + ], + "successors": [ + "0x14001db83" + ] + }, + { + "address": "0x14001db83", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001db83", + "size": 7, + "mnemonic": "movsxd", + "operands": "rsi, dword ptr [rbp + 0xc0]" + }, + { + "address": "0x14001db8a", + "size": 2, + "mnemonic": "test", + "operands": "esi, esi" + }, + { + "address": "0x14001db8c", + "size": 2, + "mnemonic": "jle", + "operands": "0x14001db9e" + }, + { + "address": "0x14001db8e", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x14001db91", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r12" + }, + { + "address": "0x14001db94", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d9c0" + }, + { + "address": "0x14001db99", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rax" + }, + { + "address": "0x14001db9c", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001dba7" + } + ], + "successors": [ + "0x14001dba7" + ] + }, + { + "address": "0x14001dba7", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001dba7", + "size": 7, + "mnemonic": "mov", + "operands": "r15d, dword ptr [rbp + 0xc8]" + }, + { + "address": "0x14001dbae", + "size": 3, + "mnemonic": "test", + "operands": "r15d, r15d" + }, + { + "address": "0x14001dbb1", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001dbba" + }, + { + "address": "0x14001dbb3", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx]" + }, + { + "address": "0x14001dbb6", + "size": 4, + "mnemonic": "mov", + "operands": "r15d, dword ptr [rax + 0xc]" + }, + { + "address": "0x14001dbba", + "size": 2, + "mnemonic": "test", + "operands": "edi, edi" + }, + { + "address": "0x14001dbbc", + "size": 2, + "mnemonic": "je", + "operands": "0x14001dbc6" + } + ], + "successors": [ + "0x14001dbc6", + "0x14001dbbe" + ] + }, + { + "address": "0x14001dbc6", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001dbc6", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001dbc8", + "size": 3, + "mnemonic": "xorps", + "operands": "xmm0, xmm0" + }, + { + "address": "0x14001dbcb", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp + 0x28], eax" + }, + { + "address": "0x14001dbce", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rbp + 0x18], xmm0" + }, + { + "address": "0x14001dbd2", + "size": 2, + "mnemonic": "cmp", + "operands": "edi, esi" + }, + { + "address": "0x14001dbd4", + "size": 6, + "mnemonic": "je", + "operands": "0x14001dea4" + } + ], + "successors": [ + "0x14001dea4", + "0x14001dbda" + ] + }, + { + "address": "0x14001dbbe", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001dbbe", + "size": 2, + "mnemonic": "test", + "operands": "esi, esi" + }, + { + "address": "0x14001dbc0", + "size": 6, + "mnemonic": "jne", + "operands": "0x14001dc78" + }, + { + "address": "0x14001dbc6", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001dbc8", + "size": 3, + "mnemonic": "xorps", + "operands": "xmm0, xmm0" + }, + { + "address": "0x14001dbcb", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp + 0x28], eax" + }, + { + "address": "0x14001dbce", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rbp + 0x18], xmm0" + }, + { + "address": "0x14001dbd2", + "size": 2, + "mnemonic": "cmp", + "operands": "edi, esi" + }, + { + "address": "0x14001dbd4", + "size": 6, + "mnemonic": "je", + "operands": "0x14001dea4" + } + ], + "successors": [ + "0x14001dea4", + "0x14001dbda" + ] + }, + { + "address": "0x14001dea4", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001dea4", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 2" + }, + { + "address": "0x14001dea9", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001de87" + } + ], + "successors": [ + "0x14001de87" + ] + }, + { + "address": "0x14001dbda", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001dbda", + "size": 3, + "mnemonic": "cmp", + "operands": "esi, 1" + }, + { + "address": "0x14001dbdd", + "size": 6, + "mnemonic": "jg", + "operands": "0x14001dc6e" + } + ], + "successors": [ + "0x14001dc6e", + "0x14001dbe3" + ] + }, + { + "address": "0x14001de87", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001de87", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x30]" + }, + { + "address": "0x14001de8b", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rbp" + }, + { + "address": "0x14001de8e", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x14001de93", + "size": 4, + "mnemonic": "lea", + "operands": "rsp, [rbp + 0x48]" + }, + { + "address": "0x14001de97", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14001de99", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001de9b", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14001de9d", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14001de9f", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001dea0", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14001dea1", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001dea2", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001dea3", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001dc6e", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001dc6e", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 1" + }, + { + "address": "0x14001dc73", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14001de87" + } + ], + "successors": [ + "0x14001de87" + ] + }, + { + "address": "0x14001dbe3", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001dbe3", + "size": 3, + "mnemonic": "cmp", + "operands": "edi, 1" + }, + { + "address": "0x14001dbe6", + "size": 2, + "mnemonic": "jg", + "operands": "0x14001dc30" + } + ], + "successors": [ + "0x14001dc30", + "0x14001dbe8" + ] + }, + { + "address": "0x14001dc30", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001dc30", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 3" + }, + { + "address": "0x14001dc35", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14001de87" + } + ], + "successors": [ + "0x14001de87" + ] + }, + { + "address": "0x14001dbe8", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001dbe8", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp + 0x18]" + }, + { + "address": "0x14001dbec", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, r15d" + }, + { + "address": "0x14001dbef", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x245b]" + }, + { + "address": "0x14001dbf5", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001dbf7", + "size": 6, + "mnemonic": "je", + "operands": "0x14001de85" + } + ], + "successors": [ + "0x14001de85", + "0x14001dbfd" + ] + }, + { + "address": "0x14001de85", + "size": 14, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001de85", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001de87", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x30]" + }, + { + "address": "0x14001de8b", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rbp" + }, + { + "address": "0x14001de8e", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x14001de93", + "size": 4, + "mnemonic": "lea", + "operands": "rsp, [rbp + 0x48]" + }, + { + "address": "0x14001de97", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14001de99", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001de9b", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14001de9d", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14001de9f", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001dea0", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14001dea1", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001dea2", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001dea3", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001dbfd", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001dbfd", + "size": 2, + "mnemonic": "test", + "operands": "edi, edi" + }, + { + "address": "0x14001dbff", + "size": 2, + "mnemonic": "jle", + "operands": "0x14001dc3a" + }, + { + "address": "0x14001dc01", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rbp + 0x18], 2" + }, + { + "address": "0x14001dc05", + "size": 2, + "mnemonic": "jb", + "operands": "0x14001dc30" + } + ], + "successors": [ + "0x14001dc30", + "0x14001dc07" + ] + }, + { + "address": "0x14001dc07", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001dc07", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x1e]" + }, + { + "address": "0x14001dc0b", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp + 0x1e], r13b" + }, + { + "address": "0x14001dc0f", + "size": 2, + "mnemonic": "je", + "operands": "0x14001dc30" + } + ], + "successors": [ + "0x14001dc30", + "0x14001dc11" + ] + }, + { + "address": "0x14001dc11", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001dc11", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rax + 1], r13b" + }, + { + "address": "0x14001dc15", + "size": 2, + "mnemonic": "je", + "operands": "0x14001dc30" + } + ], + "successors": [ + "0x14001dc30", + "0x14001dc17" + ] + }, + { + "address": "0x14001dc17", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001dc17", + "size": 3, + "mnemonic": "mov", + "operands": "cl, byte ptr [r14]" + }, + { + "address": "0x14001dc1a", + "size": 2, + "mnemonic": "cmp", + "operands": "cl, byte ptr [rax]" + }, + { + "address": "0x14001dc1c", + "size": 2, + "mnemonic": "jb", + "operands": "0x14001dc27" + } + ], + "successors": [ + "0x14001dc27", + "0x14001dc1e" + ] + }, + { + "address": "0x14001dc27", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001dc27", + "size": 4, + "mnemonic": "add", + "operands": "rax, 2" + }, + { + "address": "0x14001dc2b", + "size": 3, + "mnemonic": "cmp", + "operands": "byte ptr [rax], r13b" + }, + { + "address": "0x14001dc2e", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001dc11" + }, + { + "address": "0x14001dc30", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 3" + }, + { + "address": "0x14001dc35", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14001de87" + } + ], + "successors": [ + "0x14001de87" + ] + }, + { + "address": "0x14001dc1e", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001dc1e", + "size": 3, + "mnemonic": "cmp", + "operands": "cl, byte ptr [rax + 1]" + }, + { + "address": "0x14001dc21", + "size": 6, + "mnemonic": "jbe", + "operands": "0x14001dea4" + }, + { + "address": "0x14001dc27", + "size": 4, + "mnemonic": "add", + "operands": "rax, 2" + }, + { + "address": "0x14001dc2b", + "size": 3, + "mnemonic": "cmp", + "operands": "byte ptr [rax], r13b" + }, + { + "address": "0x14001dc2e", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001dc11" + }, + { + "address": "0x14001dc30", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 3" + }, + { + "address": "0x14001dc35", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14001de87" + } + ], + "successors": [ + "0x14001de87" + ] + } + ] + }, + { + "address": "0x14001f0d5", + "name": "", + "blocks": [ + { + "address": "0x14001f0d5", + "size": 16, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f0d5", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f0d6", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f0da", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f0dd", + "size": 7, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rbp + 0xa0]" + }, + { + "address": "0x14001f0e4", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdx]" + }, + { + "address": "0x14001f0e7", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax + 4]" + }, + { + "address": "0x14001f0eb", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 4" + }, + { + "address": "0x14001f0f0", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x14001f0f3", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rcx + rdx + 0x48], r8" + }, + { + "address": "0x14001f0f8", + "size": 4, + "mnemonic": "cmovne", + "operands": "eax, r8d" + }, + { + "address": "0x14001f0fc", + "size": 4, + "mnemonic": "or", + "operands": "eax, dword ptr [rcx + rdx + 0x10]" + }, + { + "address": "0x14001f100", + "size": 3, + "mnemonic": "and", + "operands": "eax, 0x13" + }, + { + "address": "0x14001f103", + "size": 3, + "mnemonic": "or", + "operands": "eax, 4" + }, + { + "address": "0x14001f106", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rcx + rdx + 0x10], eax" + }, + { + "address": "0x14001f10a", + "size": 4, + "mnemonic": "test", + "operands": "dword ptr [rcx + rdx + 0x14], eax" + }, + { + "address": "0x14001f10e", + "size": 2, + "mnemonic": "je", + "operands": "0x14001f11a" + } + ], + "successors": [ + "0x14001f11a", + "0x14001f110" + ] + }, + { + "address": "0x14001f11a", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f11a", + "size": 10, + "mnemonic": "movabs", + "operands": "rax, 0" + }, + { + "address": "0x14001f124", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f128", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f129", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001f110", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f110", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14001f112", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14001f114", + "size": 5, + "mnemonic": "call", + "operands": "0x140006198" + }, + { + "address": "0x14001f119", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14001f11a", + "size": 10, + "mnemonic": "movabs", + "operands": "rax, 0" + }, + { + "address": "0x14001f124", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f128", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f129", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f135", + "name": "", + "blocks": [ + { + "address": "0x14001f135", + "size": 7, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f135", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f136", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f13a", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f13d", + "size": 10, + "mnemonic": "movabs", + "operands": "rax, 0" + }, + { + "address": "0x14001f147", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f14b", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f14c", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f155", + "name": "", + "blocks": [ + { + "address": "0x14001f155", + "size": 16, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f155", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f156", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f15a", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f15d", + "size": 7, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rbp + 0x80]" + }, + { + "address": "0x14001f164", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdx]" + }, + { + "address": "0x14001f167", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax + 4]" + }, + { + "address": "0x14001f16b", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 4" + }, + { + "address": "0x14001f170", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x14001f173", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rcx + rdx + 0x48], r8" + }, + { + "address": "0x14001f178", + "size": 4, + "mnemonic": "cmovne", + "operands": "eax, r8d" + }, + { + "address": "0x14001f17c", + "size": 4, + "mnemonic": "or", + "operands": "eax, dword ptr [rcx + rdx + 0x10]" + }, + { + "address": "0x14001f180", + "size": 3, + "mnemonic": "and", + "operands": "eax, 0x13" + }, + { + "address": "0x14001f183", + "size": 3, + "mnemonic": "or", + "operands": "eax, 4" + }, + { + "address": "0x14001f186", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rcx + rdx + 0x10], eax" + }, + { + "address": "0x14001f18a", + "size": 4, + "mnemonic": "test", + "operands": "dword ptr [rcx + rdx + 0x14], eax" + }, + { + "address": "0x14001f18e", + "size": 2, + "mnemonic": "je", + "operands": "0x14001f19a" + } + ], + "successors": [ + "0x14001f19a", + "0x14001f190" + ] + }, + { + "address": "0x14001f19a", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f19a", + "size": 10, + "mnemonic": "movabs", + "operands": "rax, 0" + }, + { + "address": "0x14001f1a4", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f1a8", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f1a9", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001f190", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f190", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14001f192", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14001f194", + "size": 5, + "mnemonic": "call", + "operands": "0x140006198" + }, + { + "address": "0x14001f199", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14001f19a", + "size": 10, + "mnemonic": "movabs", + "operands": "rax, 0" + }, + { + "address": "0x14001f1a4", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f1a8", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f1a9", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f1c3", + "name": "", + "blocks": [ + { + "address": "0x14001f1c3", + "size": 7, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f1c3", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f1c5", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f1c9", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f1cc", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbp + 0x48]" + }, + { + "address": "0x14001f1cf", + "size": 3, + "mnemonic": "and", + "operands": "eax, 1" + }, + { + "address": "0x14001f1d2", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001f1d4", + "size": 2, + "mnemonic": "je", + "operands": "0x14001f1e7" + } + ], + "successors": [ + "0x14001f1e7", + "0x14001f1d6" + ] + }, + { + "address": "0x14001f1e7", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f1e7", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f1eb", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f1ec", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001f1d6", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f1d6", + "size": 4, + "mnemonic": "and", + "operands": "dword ptr [rbp + 0x48], 0xfffffffe" + }, + { + "address": "0x14001f1da", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x30]" + }, + { + "address": "0x14001f1de", + "size": 4, + "mnemonic": "add", + "operands": "rcx, 0x10" + }, + { + "address": "0x14001f1e2", + "size": 5, + "mnemonic": "call", + "operands": "0x140002b78" + }, + { + "address": "0x14001f1e7", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f1eb", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f1ec", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f259", + "name": "", + "blocks": [ + { + "address": "0x14001f259", + "size": 9, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f259", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f25b", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f25f", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f262", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0x10" + }, + { + "address": "0x14001f267", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0xa0]" + }, + { + "address": "0x14001f26e", + "size": 5, + "mnemonic": "call", + "operands": "0x140005170" + }, + { + "address": "0x14001f273", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f277", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f278", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f279", + "name": "", + "blocks": [ + { + "address": "0x14001f279", + "size": 9, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f279", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f27b", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f27f", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f282", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0x30" + }, + { + "address": "0x14001f287", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0xc0]" + }, + { + "address": "0x14001f28e", + "size": 5, + "mnemonic": "call", + "operands": "0x140005170" + }, + { + "address": "0x14001f293", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f297", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f298", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f2bd", + "name": "", + "blocks": [ + { + "address": "0x14001f2bd", + "size": 11, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f2bd", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f2bf", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f2c3", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f2c6", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rcx" + }, + { + "address": "0x14001f2c9", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx]" + }, + { + "address": "0x14001f2cc", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rcx]" + }, + { + "address": "0x14001f2ce", + "size": 5, + "mnemonic": "call", + "operands": "0x14000dfac" + }, + { + "address": "0x14001f2d3", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14001f2d4", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f2d8", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f2d9", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f2db", + "name": "", + "blocks": [ + { + "address": "0x14001f2db", + "size": 9, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f2db", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f2dd", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f2e0", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x14001f2e3", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14001f2e5", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rax], 0xc0000005" + }, + { + "address": "0x14001f2eb", + "size": 3, + "mnemonic": "sete", + "operands": "cl" + }, + { + "address": "0x14001f2ee", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ecx" + }, + { + "address": "0x14001f2f0", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f2f1", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f2f5", + "name": "", + "blocks": [ + { + "address": "0x14001f2f5", + "size": 38, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f2f5", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f2f6", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001f2f7", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x14001f2fb", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f2fe", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x48], rcx" + }, + { + "address": "0x14001f302", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f307", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x70]" + }, + { + "address": "0x14001f30b", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x70], rcx" + }, + { + "address": "0x14001f30f", + "size": 7, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rbp + 0x88]" + }, + { + "address": "0x14001f316", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rdi + 8]" + }, + { + "address": "0x14001f31a", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f31f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x60], rbx" + }, + { + "address": "0x14001f323", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x48]" + }, + { + "address": "0x14001f327", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax]" + }, + { + "address": "0x14001f32a", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rcx + 0x38]" + }, + { + "address": "0x14001f32e", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f333", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x68], rbx" + }, + { + "address": "0x14001f337", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x48]" + }, + { + "address": "0x14001f33b", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x38], 1" + }, + { + "address": "0x14001f340", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], 0" + }, + { + "address": "0x14001f349", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], 0" + }, + { + "address": "0x14001f351", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x90]" + }, + { + "address": "0x14001f358", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14001f35d", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rdi" + }, + { + "address": "0x14001f360", + "size": 7, + "mnemonic": "mov", + "operands": "r8, qword ptr [rbp + 0x80]" + }, + { + "address": "0x14001f367", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rbp + 0x78]" + }, + { + "address": "0x14001f36b", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx]" + }, + { + "address": "0x14001f36e", + "size": 5, + "mnemonic": "call", + "operands": "0x14000952c" + }, + { + "address": "0x14001f373", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f378", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x70], 0" + }, + { + "address": "0x14001f380", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rbp + 0x40], 1" + }, + { + "address": "0x14001f387", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rbp + 0x44], 1" + }, + { + "address": "0x14001f38e", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbp + 0x44]" + }, + { + "address": "0x14001f391", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x40" + }, + { + "address": "0x14001f395", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001f396", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f397", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001f398", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f39c", + "name": "", + "blocks": [ + { + "address": "0x14001f39c", + "size": 41, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f39c", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f39d", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001f39e", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x14001f3a2", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f3a5", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x48], rcx" + }, + { + "address": "0x14001f3a9", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f3ae", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x70]" + }, + { + "address": "0x14001f3b2", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x70], rcx" + }, + { + "address": "0x14001f3b6", + "size": 7, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rbp + 0x88]" + }, + { + "address": "0x14001f3bd", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rdi + 8]" + }, + { + "address": "0x14001f3c1", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f3c6", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x60], rbx" + }, + { + "address": "0x14001f3ca", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x48]" + }, + { + "address": "0x14001f3ce", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax]" + }, + { + "address": "0x14001f3d1", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rcx + 0x38]" + }, + { + "address": "0x14001f3d5", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f3da", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x68], rbx" + }, + { + "address": "0x14001f3de", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f3e3", + "size": 6, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbp + 0xa8]" + }, + { + "address": "0x14001f3e9", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x78], ecx" + }, + { + "address": "0x14001f3ec", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x48]" + }, + { + "address": "0x14001f3f0", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x38], 1" + }, + { + "address": "0x14001f3f5", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], 0" + }, + { + "address": "0x14001f3fe", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], 0" + }, + { + "address": "0x14001f406", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x90]" + }, + { + "address": "0x14001f40d", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14001f412", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rdi" + }, + { + "address": "0x14001f415", + "size": 7, + "mnemonic": "mov", + "operands": "r8, qword ptr [rbp + 0x80]" + }, + { + "address": "0x14001f41c", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rbp + 0x78]" + }, + { + "address": "0x14001f420", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx]" + }, + { + "address": "0x14001f423", + "size": 5, + "mnemonic": "call", + "operands": "0x140009534" + }, + { + "address": "0x14001f428", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f42d", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x70], 0" + }, + { + "address": "0x14001f435", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rbp + 0x40], 1" + }, + { + "address": "0x14001f43c", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rbp + 0x44], 1" + }, + { + "address": "0x14001f443", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbp + 0x44]" + }, + { + "address": "0x14001f446", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x40" + }, + { + "address": "0x14001f44a", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001f44b", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f44c", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001f44d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f451", + "name": "", + "blocks": [ + { + "address": "0x14001f451", + "size": 6, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f451", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f452", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x14001f456", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f459", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x30], rcx" + }, + { + "address": "0x14001f45d", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp + 0x58], 0" + }, + { + "address": "0x14001f461", + "size": 2, + "mnemonic": "je", + "operands": "0x14001f4cf" + } + ], + "successors": [ + "0x14001f4cf", + "0x14001f463" + ] + }, + { + "address": "0x14001f4cf", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f4cf", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rbp + 0x20], 0" + }, + { + "address": "0x14001f4d6", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbp + 0x20]" + }, + { + "address": "0x14001f4d9", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14001f4dd", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f4de", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001f4df", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001f463", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f463", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x30]" + }, + { + "address": "0x14001f467", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax]" + }, + { + "address": "0x14001f46a", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x28], rcx" + }, + { + "address": "0x14001f46e", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x28]" + }, + { + "address": "0x14001f472", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rax], 0xe06d7363" + }, + { + "address": "0x14001f478", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001f4cf" + }, + { + "address": "0x14001f47a", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x28]" + }, + { + "address": "0x14001f47e", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rax + 0x18], 4" + }, + { + "address": "0x14001f482", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001f4cf" + }, + { + "address": "0x14001f484", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x28]" + }, + { + "address": "0x14001f488", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rax + 0x20], 0x19930520" + }, + { + "address": "0x14001f48f", + "size": 2, + "mnemonic": "je", + "operands": "0x14001f4ab" + } + ], + "successors": [ + "0x14001f4ab", + "0x14001f491" + ] + }, + { + "address": "0x14001f4ab", + "size": 15, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f4ab", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f4b0", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x28]" + }, + { + "address": "0x14001f4b4", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x20], rcx" + }, + { + "address": "0x14001f4b8", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x30]" + }, + { + "address": "0x14001f4bc", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rax + 8]" + }, + { + "address": "0x14001f4c0", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f4c5", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x28], rbx" + }, + { + "address": "0x14001f4c9", + "size": 5, + "mnemonic": "call", + "operands": "0x140010b70" + }, + { + "address": "0x14001f4ce", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14001f4cf", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rbp + 0x20], 0" + }, + { + "address": "0x14001f4d6", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbp + 0x20]" + }, + { + "address": "0x14001f4d9", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14001f4dd", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f4de", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001f4df", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001f491", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f491", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x28]" + }, + { + "address": "0x14001f495", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rax + 0x20], 0x19930521" + }, + { + "address": "0x14001f49c", + "size": 2, + "mnemonic": "je", + "operands": "0x14001f4ab" + } + ], + "successors": [ + "0x14001f4ab", + "0x14001f49e" + ] + }, + { + "address": "0x14001f49e", + "size": 18, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f49e", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x28]" + }, + { + "address": "0x14001f4a2", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rax + 0x20], 0x19930522" + }, + { + "address": "0x14001f4a9", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001f4cf" + }, + { + "address": "0x14001f4ab", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f4b0", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x28]" + }, + { + "address": "0x14001f4b4", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x20], rcx" + }, + { + "address": "0x14001f4b8", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x30]" + }, + { + "address": "0x14001f4bc", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rax + 8]" + }, + { + "address": "0x14001f4c0", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f4c5", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x28], rbx" + }, + { + "address": "0x14001f4c9", + "size": 5, + "mnemonic": "call", + "operands": "0x140010b70" + }, + { + "address": "0x14001f4ce", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14001f4cf", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rbp + 0x20], 0" + }, + { + "address": "0x14001f4d6", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbp + 0x20]" + }, + { + "address": "0x14001f4d9", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14001f4dd", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f4de", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001f4df", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f4e1", + "name": "", + "blocks": [ + { + "address": "0x14001f4e1", + "size": 8, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f4e1", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f4e3", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x14001f4e7", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f4ea", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f4ef", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x78], 0xfffffffe" + }, + { + "address": "0x14001f4f6", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x40" + }, + { + "address": "0x14001f4fa", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f4fb", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f4fd", + "name": "", + "blocks": [ + { + "address": "0x14001f4fd", + "size": 10, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f4fd", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f4ff", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f503", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f506", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbp + 0x20]" + }, + { + "address": "0x14001f50a", + "size": 7, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rbp + 0xb8]" + }, + { + "address": "0x14001f511", + "size": 5, + "mnemonic": "call", + "operands": "0x140009cfc" + }, + { + "address": "0x14001f516", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14001f517", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f51b", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f51c", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f520", + "name": "", + "blocks": [ + { + "address": "0x14001f520", + "size": 14, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f520", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f521", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x14001f525", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f528", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x38]" + }, + { + "address": "0x14001f52c", + "size": 5, + "mnemonic": "call", + "operands": "0x140006d54" + }, + { + "address": "0x14001f531", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rbp + 0x20], 0" + }, + { + "address": "0x14001f535", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001f57f" + }, + { + "address": "0x14001f537", + "size": 7, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rbp + 0xb8]" + }, + { + "address": "0x14001f53e", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rbx], 0xe06d7363" + }, + { + "address": "0x14001f544", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001f57f" + }, + { + "address": "0x14001f546", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rbx + 0x18], 4" + }, + { + "address": "0x14001f54a", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001f57f" + }, + { + "address": "0x14001f54c", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rbx + 0x20], 0x19930520" + }, + { + "address": "0x14001f553", + "size": 2, + "mnemonic": "je", + "operands": "0x14001f567" + } + ], + "successors": [ + "0x14001f567", + "0x14001f555" + ] + }, + { + "address": "0x14001f567", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f567", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x28]" + }, + { + "address": "0x14001f56b", + "size": 5, + "mnemonic": "call", + "operands": "0x140007010" + }, + { + "address": "0x14001f570", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001f572", + "size": 2, + "mnemonic": "je", + "operands": "0x14001f57f" + } + ], + "successors": [ + "0x14001f57f", + "0x14001f574" + ] + }, + { + "address": "0x14001f555", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f555", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rbx + 0x20], 0x19930521" + }, + { + "address": "0x14001f55c", + "size": 2, + "mnemonic": "je", + "operands": "0x14001f567" + } + ], + "successors": [ + "0x14001f567", + "0x14001f55e" + ] + }, + { + "address": "0x14001f57f", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f57f", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f584", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0xc0]" + }, + { + "address": "0x14001f58b", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x20], rcx" + }, + { + "address": "0x14001f58f", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f594", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x40]" + }, + { + "address": "0x14001f598", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x28], rcx" + }, + { + "address": "0x14001f59c", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14001f5a0", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f5a1", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001f5a2", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001f574", + "size": 14, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f574", + "size": 2, + "mnemonic": "mov", + "operands": "dl, 1" + }, + { + "address": "0x14001f576", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x14001f579", + "size": 5, + "mnemonic": "call", + "operands": "0x140006f98" + }, + { + "address": "0x14001f57e", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14001f57f", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f584", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0xc0]" + }, + { + "address": "0x14001f58b", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x20], rcx" + }, + { + "address": "0x14001f58f", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f594", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x40]" + }, + { + "address": "0x14001f598", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x28], rcx" + }, + { + "address": "0x14001f59c", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14001f5a0", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f5a1", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001f5a2", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001f55e", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f55e", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rbx + 0x20], 0x19930522" + }, + { + "address": "0x14001f565", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001f57f" + }, + { + "address": "0x14001f567", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x28]" + }, + { + "address": "0x14001f56b", + "size": 5, + "mnemonic": "call", + "operands": "0x140007010" + }, + { + "address": "0x14001f570", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001f572", + "size": 2, + "mnemonic": "je", + "operands": "0x14001f57f" + } + ], + "successors": [ + "0x14001f57f", + "0x14001f574" + ] + } + ] + }, + { + "address": "0x14001f5a4", + "name": "", + "blocks": [ + { + "address": "0x14001f5a4", + "size": 11, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f5a4", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f5a6", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f5aa", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f5ad", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp + 0x20]" + }, + { + "address": "0x14001f5b1", + "size": 7, + "mnemonic": "mov", + "operands": "r8d, dword ptr [rbp + 0xc8]" + }, + { + "address": "0x14001f5b8", + "size": 7, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rbp + 0xd8]" + }, + { + "address": "0x14001f5bf", + "size": 5, + "mnemonic": "call", + "operands": "0x140009d94" + }, + { + "address": "0x14001f5c4", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14001f5c5", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f5c9", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f5ca", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f5ce", + "name": "", + "blocks": [ + { + "address": "0x14001f5ce", + "size": 14, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f5ce", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f5cf", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x14001f5d3", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f5d6", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x40]" + }, + { + "address": "0x14001f5da", + "size": 5, + "mnemonic": "call", + "operands": "0x140006d54" + }, + { + "address": "0x14001f5df", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rbp + 0x20], 0" + }, + { + "address": "0x14001f5e3", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001f62d" + }, + { + "address": "0x14001f5e5", + "size": 7, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rbp + 0xd8]" + }, + { + "address": "0x14001f5ec", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rbx], 0xe06d7363" + }, + { + "address": "0x14001f5f2", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001f62d" + }, + { + "address": "0x14001f5f4", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rbx + 0x18], 4" + }, + { + "address": "0x14001f5f8", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001f62d" + }, + { + "address": "0x14001f5fa", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rbx + 0x20], 0x19930520" + }, + { + "address": "0x14001f601", + "size": 2, + "mnemonic": "je", + "operands": "0x14001f615" + } + ], + "successors": [ + "0x14001f615", + "0x14001f603" + ] + }, + { + "address": "0x14001f615", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f615", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x28]" + }, + { + "address": "0x14001f619", + "size": 5, + "mnemonic": "call", + "operands": "0x140007010" + }, + { + "address": "0x14001f61e", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001f620", + "size": 2, + "mnemonic": "je", + "operands": "0x14001f62d" + } + ], + "successors": [ + "0x14001f62d", + "0x14001f622" + ] + }, + { + "address": "0x14001f603", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f603", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rbx + 0x20], 0x19930521" + }, + { + "address": "0x14001f60a", + "size": 2, + "mnemonic": "je", + "operands": "0x14001f615" + } + ], + "successors": [ + "0x14001f615", + "0x14001f60c" + ] + }, + { + "address": "0x14001f62d", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f62d", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f632", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x30]" + }, + { + "address": "0x14001f636", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x20], rcx" + }, + { + "address": "0x14001f63a", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f63f", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x48]" + }, + { + "address": "0x14001f643", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x28], rcx" + }, + { + "address": "0x14001f647", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f64c", + "size": 6, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbp + 0xc0]" + }, + { + "address": "0x14001f652", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x78], ecx" + }, + { + "address": "0x14001f655", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14001f659", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f65a", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001f65b", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001f622", + "size": 17, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f622", + "size": 2, + "mnemonic": "mov", + "operands": "dl, 1" + }, + { + "address": "0x14001f624", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x14001f627", + "size": 5, + "mnemonic": "call", + "operands": "0x140006f98" + }, + { + "address": "0x14001f62c", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14001f62d", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f632", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x30]" + }, + { + "address": "0x14001f636", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x20], rcx" + }, + { + "address": "0x14001f63a", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f63f", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x48]" + }, + { + "address": "0x14001f643", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x28], rcx" + }, + { + "address": "0x14001f647", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f64c", + "size": 6, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbp + 0xc0]" + }, + { + "address": "0x14001f652", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x78], ecx" + }, + { + "address": "0x14001f655", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14001f659", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f65a", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001f65b", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001f60c", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f60c", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rbx + 0x20], 0x19930522" + }, + { + "address": "0x14001f613", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001f62d" + }, + { + "address": "0x14001f615", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x28]" + }, + { + "address": "0x14001f619", + "size": 5, + "mnemonic": "call", + "operands": "0x140007010" + }, + { + "address": "0x14001f61e", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001f620", + "size": 2, + "mnemonic": "je", + "operands": "0x14001f62d" + } + ], + "successors": [ + "0x14001f62d", + "0x14001f622" + ] + } + ] + }, + { + "address": "0x14001f65d", + "name": "", + "blocks": [ + { + "address": "0x14001f65d", + "size": 8, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f65d", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f65f", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f663", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f666", + "size": 5, + "mnemonic": "call", + "operands": "0x140007064" + }, + { + "address": "0x14001f66b", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14001f66c", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f670", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f671", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f673", + "name": "", + "blocks": [ + { + "address": "0x14001f673", + "size": 11, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f673", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f675", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f679", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f67c", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f681", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rax + 0x30], 0" + }, + { + "address": "0x14001f685", + "size": 2, + "mnemonic": "jle", + "operands": "0x14001f68f" + }, + { + "address": "0x14001f687", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f68c", + "size": 3, + "mnemonic": "dec", + "operands": "dword ptr [rax + 0x30]" + }, + { + "address": "0x14001f68f", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f693", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f694", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f696", + "name": "", + "blocks": [ + { + "address": "0x14001f696", + "size": 8, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f696", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f698", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001f69c", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f69f", + "size": 5, + "mnemonic": "call", + "operands": "0x140007064" + }, + { + "address": "0x14001f6a4", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14001f6a5", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001f6a9", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f6aa", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f6ac", + "name": "", + "blocks": [ + { + "address": "0x14001f6ac", + "size": 11, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f6ac", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f6ae", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001f6b2", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f6b5", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f6ba", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rax + 0x30], 0" + }, + { + "address": "0x14001f6be", + "size": 2, + "mnemonic": "jle", + "operands": "0x14001f6c8" + }, + { + "address": "0x14001f6c0", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14001f6c5", + "size": 3, + "mnemonic": "dec", + "operands": "dword ptr [rax + 0x30]" + }, + { + "address": "0x14001f6c8", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001f6cc", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f6cd", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f6cf", + "name": "", + "blocks": [ + { + "address": "0x14001f6cf", + "size": 7, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f6cf", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f6d1", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001f6d5", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f6d8", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x40]" + }, + { + "address": "0x14001f6dc", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001f6e0", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f6e1", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000b204" + } + ], + "successors": [ + "0x14000b204" + ] + }, + { + "address": "0x14000b204", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b204", + "size": 4, + "mnemonic": "add", + "operands": "rcx, 0x30" + }, + { + "address": "0x14000b208", + "size": 7, + "mnemonic": "jmp", + "operands": "qword ptr [rip + 0x14e09]" + } + ], + "successors": [ + "0x140020018" + ] + }, + { + "address": "0x140020018", + "size": 0, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f6e7", + "name": "", + "blocks": [ + { + "address": "0x14001f6e7", + "size": 8, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f6e7", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f6e9", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f6ed", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f6f0", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x48]" + }, + { + "address": "0x14001f6f4", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx]" + }, + { + "address": "0x14001f6f7", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f6fb", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f6fc", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000b204" + } + ], + "successors": [ + "0x14000b204" + ] + } + ] + }, + { + "address": "0x14001f702", + "name": "", + "blocks": [ + { + "address": "0x14001f702", + "size": 8, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f702", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f704", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f708", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f70b", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x98]" + }, + { + "address": "0x14001f712", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rcx]" + }, + { + "address": "0x14001f714", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f718", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f719", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000ca74" + } + ], + "successors": [ + "0x14000ca74" + ] + }, + { + "address": "0x14000ca74", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ca74", + "size": 3, + "mnemonic": "movsxd", + "operands": "rax, ecx" + }, + { + "address": "0x14000ca77", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + rax*4]" + }, + { + "address": "0x14000ca7b", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x2637e]" + }, + { + "address": "0x14000ca82", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + rcx*8]" + }, + { + "address": "0x14000ca86", + "size": 7, + "mnemonic": "jmp", + "operands": "qword ptr [rip + 0x1358b]" + } + ], + "successors": [ + "0x140020018" + ] + } + ] + }, + { + "address": "0x14001f71f", + "name": "", + "blocks": [ + { + "address": "0x14001f71f", + "size": 9, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f71f", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f721", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f725", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f728", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x40]" + }, + { + "address": "0x14001f72c", + "size": 5, + "mnemonic": "call", + "operands": "0x14000b204" + }, + { + "address": "0x14001f731", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14001f732", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f736", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f737", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f739", + "name": "", + "blocks": [ + { + "address": "0x14001f739", + "size": 9, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f739", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f73b", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001f73f", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f742", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x58]" + }, + { + "address": "0x14001f746", + "size": 5, + "mnemonic": "call", + "operands": "0x14000b204" + }, + { + "address": "0x14001f74b", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14001f74c", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001f750", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f751", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f753", + "name": "", + "blocks": [ + { + "address": "0x14001f753", + "size": 7, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f753", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f755", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001f759", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f75c", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x60]" + }, + { + "address": "0x14001f760", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001f764", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f765", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000b204" + } + ], + "successors": [ + "0x14000b204" + ] + } + ] + }, + { + "address": "0x14001f76b", + "name": "", + "blocks": [ + { + "address": "0x14001f76b", + "size": 7, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f76b", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f76d", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f771", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f774", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x38]" + }, + { + "address": "0x14001f778", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f77c", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f77d", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000b204" + } + ], + "successors": [ + "0x14000b204" + ] + } + ] + }, + { + "address": "0x14001f783", + "name": "", + "blocks": [ + { + "address": "0x14001f783", + "size": 8, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f783", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f785", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f789", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f78c", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x48]" + }, + { + "address": "0x14001f790", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rcx]" + }, + { + "address": "0x14001f792", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f796", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f797", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000ca74" + } + ], + "successors": [ + "0x14000ca74" + ] + } + ] + }, + { + "address": "0x14001f7a0", + "name": "", + "blocks": [ + { + "address": "0x14001f7a0", + "size": 7, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f7a0", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f7a2", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f7a6", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f7a9", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14001f7ab", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f7af", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f7b0", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000ca74" + } + ], + "successors": [ + "0x14000ca74" + ] + } + ] + }, + { + "address": "0x14001f7b6", + "name": "", + "blocks": [ + { + "address": "0x14001f7b6", + "size": 7, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f7b6", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f7b8", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f7bc", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f7bf", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14001f7c1", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f7c5", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f7c6", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000ca74" + } + ], + "successors": [ + "0x14000ca74" + ] + } + ] + }, + { + "address": "0x14001f7cc", + "name": "", + "blocks": [ + { + "address": "0x14001f7cc", + "size": 15, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f7cc", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f7ce", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f7d2", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f7d5", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x28], rcx" + }, + { + "address": "0x14001f7d9", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x14001f7dc", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rax]" + }, + { + "address": "0x14001f7de", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp + 0x24], ecx" + }, + { + "address": "0x14001f7e1", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001f7e3", + "size": 6, + "mnemonic": "cmp", + "operands": "ecx, 0xe06d7363" + }, + { + "address": "0x14001f7e9", + "size": 3, + "mnemonic": "sete", + "operands": "al" + }, + { + "address": "0x14001f7ec", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp + 0x20], eax" + }, + { + "address": "0x14001f7ef", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbp + 0x20]" + }, + { + "address": "0x14001f7f2", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f7f6", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f7f7", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f7f9", + "name": "", + "blocks": [ + { + "address": "0x14001f7f9", + "size": 8, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f7f9", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f7fb", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f7ff", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f802", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x58]" + }, + { + "address": "0x14001f806", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rcx]" + }, + { + "address": "0x14001f808", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f80c", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f80d", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000ca74" + } + ], + "successors": [ + "0x14000ca74" + ] + } + ] + }, + { + "address": "0x14001f813", + "name": "", + "blocks": [ + { + "address": "0x14001f813", + "size": 10, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f813", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f815", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f819", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f81c", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x48]" + }, + { + "address": "0x14001f820", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax]" + }, + { + "address": "0x14001f823", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rcx]" + }, + { + "address": "0x14001f826", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rdx + 0x3a8], 0xffffffef" + }, + { + "address": "0x14001f82d", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f831", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f832", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f834", + "name": "", + "blocks": [ + { + "address": "0x14001f834", + "size": 7, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f834", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f836", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f83a", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f83d", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 8" + }, + { + "address": "0x14001f842", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f846", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f847", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000ca74" + } + ], + "successors": [ + "0x14000ca74" + ] + } + ] + }, + { + "address": "0x14001f84d", + "name": "", + "blocks": [ + { + "address": "0x14001f84d", + "size": 7, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f84d", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f84f", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f853", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f856", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 7" + }, + { + "address": "0x14001f85b", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f85f", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f860", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000ca74" + } + ], + "successors": [ + "0x14000ca74" + ] + } + ] + }, + { + "address": "0x14001f866", + "name": "", + "blocks": [ + { + "address": "0x14001f866", + "size": 8, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f866", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f868", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f86c", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f86f", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x48]" + }, + { + "address": "0x14001f873", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rcx]" + }, + { + "address": "0x14001f875", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f879", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f87a", + "size": 5, + "mnemonic": "jmp", + "operands": "0x1400193b8" + } + ], + "successors": [ + "0x1400193b8" + ] + }, + { + "address": "0x1400193b8", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400193b8", + "size": 3, + "mnemonic": "movsxd", + "operands": "rdx, ecx" + }, + { + "address": "0x1400193bb", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip + 0x19f3e]" + }, + { + "address": "0x1400193c2", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdx" + }, + { + "address": "0x1400193c5", + "size": 3, + "mnemonic": "and", + "operands": "edx, 0x3f" + }, + { + "address": "0x1400193c8", + "size": 4, + "mnemonic": "sar", + "operands": "rax, 6" + }, + { + "address": "0x1400193cc", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rdx + rdx*8]" + }, + { + "address": "0x1400193d0", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [r8 + rax*8]" + }, + { + "address": "0x1400193d4", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + rcx*8]" + }, + { + "address": "0x1400193d8", + "size": 7, + "mnemonic": "jmp", + "operands": "qword ptr [rip + 0x6c39]" + } + ], + "successors": [ + "0x140020018" + ] + } + ] + }, + { + "address": "0x14001f880", + "name": "", + "blocks": [ + { + "address": "0x14001f880", + "size": 7, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f880", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f882", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001f886", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f889", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbp + 0x60]" + }, + { + "address": "0x14001f88c", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001f890", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f891", + "size": 5, + "mnemonic": "jmp", + "operands": "0x1400193b8" + } + ], + "successors": [ + "0x1400193b8" + ] + } + ] + }, + { + "address": "0x14001f897", + "name": "", + "blocks": [ + { + "address": "0x14001f897", + "size": 7, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f897", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f899", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f89d", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f8a0", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbp + 0x40]" + }, + { + "address": "0x14001f8a3", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f8a7", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f8a8", + "size": 5, + "mnemonic": "jmp", + "operands": "0x1400193b8" + } + ], + "successors": [ + "0x1400193b8" + ] + } + ] + }, + { + "address": "0x14001f8ae", + "name": "", + "blocks": [ + { + "address": "0x14001f8ae", + "size": 5, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f8ae", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f8b0", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f8b4", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f8b7", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp + 0x70], 0" + }, + { + "address": "0x14001f8bb", + "size": 2, + "mnemonic": "je", + "operands": "0x14001f8c8" + } + ], + "successors": [ + "0x14001f8c8", + "0x14001f8bd" + ] + }, + { + "address": "0x14001f8c8", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f8c8", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f8cc", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f8cd", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001f8bd", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f8bd", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 3" + }, + { + "address": "0x14001f8c2", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca74" + }, + { + "address": "0x14001f8c7", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14001f8c8", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f8cc", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f8cd", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001f8cf", + "name": "", + "blocks": [ + { + "address": "0x14001f8cf", + "size": 8, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f8cf", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f8d1", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f8d5", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f8d8", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x68]" + }, + { + "address": "0x14001f8dc", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rcx]" + }, + { + "address": "0x14001f8de", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f8e2", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f8e3", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000ca74" + } + ], + "successors": [ + "0x14000ca74" + ] + } + ] + }, + { + "address": "0x14001f8e9", + "name": "", + "blocks": [ + { + "address": "0x14001f8e9", + "size": 7, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f8e9", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f8eb", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f8ef", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f8f2", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 5" + }, + { + "address": "0x14001f8f7", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f8fb", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f8fc", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000ca74" + } + ], + "successors": [ + "0x14000ca74" + ] + } + ] + }, + { + "address": "0x14001f902", + "name": "", + "blocks": [ + { + "address": "0x14001f902", + "size": 7, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f902", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f904", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f908", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f90b", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 4" + }, + { + "address": "0x14001f910", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f914", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f915", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000ca74" + } + ], + "successors": [ + "0x14000ca74" + ] + } + ] + }, + { + "address": "0x14001f920", + "name": "", + "blocks": [ + { + "address": "0x14001f920", + "size": 11, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f920", + "size": 2, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14001f922", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f926", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x14001f929", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x14001f92c", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14001f92e", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rax], 0xc0000005" + }, + { + "address": "0x14001f934", + "size": 3, + "mnemonic": "sete", + "operands": "cl" + }, + { + "address": "0x14001f937", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ecx" + }, + { + "address": "0x14001f939", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001f93d", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14001f93e", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400060d8", + "name": "", + "blocks": [ + { + "address": "0x1400060d8", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400060d8", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x1400060da", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x2d788], eax" + }, + { + "address": "0x1400060e0", + "size": 3, + "mnemonic": "setne", + "operands": "al" + }, + { + "address": "0x1400060e3", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400057f0", + "name": "", + "blocks": [ + { + "address": "0x1400057f0", + "size": 24, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400057f0", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbx" + }, + { + "address": "0x1400057f5", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rbp" + }, + { + "address": "0x1400057fa", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rsi" + }, + { + "address": "0x1400057ff", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140005800", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x10" + }, + { + "address": "0x140005804", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140005806", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x140005808", + "size": 2, + "mnemonic": "cpuid", + "operands": "" + }, + { + "address": "0x14000580a", + "size": 6, + "mnemonic": "xor", + "operands": "ecx, 0x6c65746e" + }, + { + "address": "0x140005810", + "size": 6, + "mnemonic": "xor", + "operands": "edx, 0x49656e69" + }, + { + "address": "0x140005816", + "size": 2, + "mnemonic": "or", + "operands": "edx, ecx" + }, + { + "address": "0x140005818", + "size": 2, + "mnemonic": "mov", + "operands": "ebp, eax" + }, + { + "address": "0x14000581a", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 1" + }, + { + "address": "0x14000581f", + "size": 6, + "mnemonic": "xor", + "operands": "ebx, 0x756e6547" + }, + { + "address": "0x140005825", + "size": 2, + "mnemonic": "or", + "operands": "edx, ebx" + }, + { + "address": "0x140005827", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rax - 1]" + }, + { + "address": "0x14000582a", + "size": 2, + "mnemonic": "cpuid", + "operands": "" + }, + { + "address": "0x14000582c", + "size": 2, + "mnemonic": "mov", + "operands": "edi, ecx" + }, + { + "address": "0x14000582e", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000588e" + }, + { + "address": "0x140005830", + "size": 5, + "mnemonic": "and", + "operands": "eax, 0xfff3ff0" + }, + { + "address": "0x140005835", + "size": 11, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x2b860], 0x8000" + }, + { + "address": "0x140005840", + "size": 11, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x2b85d], 0xffffffffffffffff" + }, + { + "address": "0x14000584b", + "size": 5, + "mnemonic": "cmp", + "operands": "eax, 0x106c0" + }, + { + "address": "0x140005850", + "size": 2, + "mnemonic": "je", + "operands": "0x14000587a" + } + ], + "successors": [ + "0x14000587a", + "0x140005852" + ] + }, + { + "address": "0x14000587a", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000587a", + "size": 7, + "mnemonic": "mov", + "operands": "r8d, dword ptr [rip + 0x2cebb]" + }, + { + "address": "0x140005881", + "size": 4, + "mnemonic": "or", + "operands": "r8d, 1" + }, + { + "address": "0x140005885", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2ceb0], r8d" + }, + { + "address": "0x14000588c", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140005895" + } + ], + "successors": [ + "0x140005895" + ] + }, + { + "address": "0x140005852", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005852", + "size": 5, + "mnemonic": "cmp", + "operands": "eax, 0x20660" + }, + { + "address": "0x140005857", + "size": 2, + "mnemonic": "je", + "operands": "0x14000587a" + } + ], + "successors": [ + "0x14000587a", + "0x140005859" + ] + }, + { + "address": "0x140005895", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005895", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x140005898", + "size": 3, + "mnemonic": "mov", + "operands": "esi, r9d" + }, + { + "address": "0x14000589b", + "size": 3, + "mnemonic": "mov", + "operands": "r10d, r9d" + }, + { + "address": "0x14000589e", + "size": 3, + "mnemonic": "mov", + "operands": "r11d, r9d" + }, + { + "address": "0x1400058a1", + "size": 3, + "mnemonic": "cmp", + "operands": "ebp, 7" + }, + { + "address": "0x1400058a4", + "size": 2, + "mnemonic": "jl", + "operands": "0x1400058e6" + } + ], + "successors": [ + "0x1400058e6", + "0x1400058a6" + ] + }, + { + "address": "0x140005859", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005859", + "size": 5, + "mnemonic": "cmp", + "operands": "eax, 0x20670" + }, + { + "address": "0x14000585e", + "size": 2, + "mnemonic": "je", + "operands": "0x14000587a" + } + ], + "successors": [ + "0x14000587a", + "0x140005860" + ] + }, + { + "address": "0x1400058e6", + "size": 31, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400058e6", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x2b7a3]" + }, + { + "address": "0x1400058ed", + "size": 4, + "mnemonic": "and", + "operands": "rax, 0xfffffffffffffffe" + }, + { + "address": "0x1400058f1", + "size": 10, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2b79d], 1" + }, + { + "address": "0x1400058fb", + "size": 10, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2b797], 2" + }, + { + "address": "0x140005905", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x2b784], rax" + }, + { + "address": "0x14000590c", + "size": 4, + "mnemonic": "bt", + "operands": "edi, 0x14" + }, + { + "address": "0x140005910", + "size": 2, + "mnemonic": "jae", + "operands": "0x140005931" + }, + { + "address": "0x140005912", + "size": 4, + "mnemonic": "and", + "operands": "rax, 0xffffffffffffffef" + }, + { + "address": "0x140005916", + "size": 10, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2b778], 2" + }, + { + "address": "0x140005920", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x2b769], rax" + }, + { + "address": "0x140005927", + "size": 10, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2b76b], 6" + }, + { + "address": "0x140005931", + "size": 4, + "mnemonic": "bt", + "operands": "edi, 0x1b" + }, + { + "address": "0x140005935", + "size": 6, + "mnemonic": "jae", + "operands": "0x140005a6e" + }, + { + "address": "0x14000593b", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14000593d", + "size": 3, + "mnemonic": "xgetbv", + "operands": "" + }, + { + "address": "0x140005940", + "size": 4, + "mnemonic": "shl", + "operands": "rdx, 0x20" + }, + { + "address": "0x140005944", + "size": 3, + "mnemonic": "or", + "operands": "rdx, rax" + }, + { + "address": "0x140005947", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rdx" + }, + { + "address": "0x14000594c", + "size": 4, + "mnemonic": "bt", + "operands": "edi, 0x1c" + }, + { + "address": "0x140005950", + "size": 6, + "mnemonic": "jae", + "operands": "0x140005a52" + }, + { + "address": "0x140005956", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x20]" + }, + { + "address": "0x14000595b", + "size": 2, + "mnemonic": "and", + "operands": "al, 6" + }, + { + "address": "0x14000595d", + "size": 2, + "mnemonic": "cmp", + "operands": "al, 6" + }, + { + "address": "0x14000595f", + "size": 6, + "mnemonic": "jne", + "operands": "0x140005a52" + }, + { + "address": "0x140005965", + "size": 6, + "mnemonic": "mov", + "operands": "eax, dword ptr [rip + 0x2b731]" + }, + { + "address": "0x14000596b", + "size": 2, + "mnemonic": "mov", + "operands": "dl, 0xe0" + }, + { + "address": "0x14000596d", + "size": 3, + "mnemonic": "or", + "operands": "eax, 8" + }, + { + "address": "0x140005970", + "size": 10, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2b71e], 3" + }, + { + "address": "0x14000597a", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2b71c], eax" + }, + { + "address": "0x140005980", + "size": 4, + "mnemonic": "test", + "operands": "r9b, 0x20" + }, + { + "address": "0x140005984", + "size": 2, + "mnemonic": "je", + "operands": "0x1400059e8" + } + ], + "successors": [ + "0x1400059e8", + "0x140005986" + ] + }, + { + "address": "0x1400058a6", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400058a6", + "size": 4, + "mnemonic": "lea", + "operands": "eax, [r9 + 7]" + }, + { + "address": "0x1400058aa", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x1400058ac", + "size": 2, + "mnemonic": "cpuid", + "operands": "" + }, + { + "address": "0x1400058ae", + "size": 2, + "mnemonic": "mov", + "operands": "esi, edx" + }, + { + "address": "0x1400058b0", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, ebx" + }, + { + "address": "0x1400058b3", + "size": 4, + "mnemonic": "bt", + "operands": "ebx, 9" + }, + { + "address": "0x1400058b7", + "size": 2, + "mnemonic": "jae", + "operands": "0x1400058c4" + }, + { + "address": "0x1400058b9", + "size": 4, + "mnemonic": "or", + "operands": "r8d, 2" + }, + { + "address": "0x1400058bd", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2ce78], r8d" + }, + { + "address": "0x1400058c4", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x1400058c7", + "size": 2, + "mnemonic": "jl", + "operands": "0x1400058d6" + } + ], + "successors": [ + "0x1400058d6", + "0x1400058c9" + ] + }, + { + "address": "0x140005860", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005860", + "size": 5, + "mnemonic": "add", + "operands": "eax, 0xfffcf9b0" + }, + { + "address": "0x140005865", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 0x20" + }, + { + "address": "0x140005868", + "size": 2, + "mnemonic": "ja", + "operands": "0x14000588e" + } + ], + "successors": [ + "0x14000588e", + "0x14000586a" + ] + }, + { + "address": "0x1400059e8", + "size": 38, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400059e8", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x2b6a1]" + }, + { + "address": "0x1400059ef", + "size": 4, + "mnemonic": "bt", + "operands": "esi, 0x17" + }, + { + "address": "0x1400059f3", + "size": 2, + "mnemonic": "jae", + "operands": "0x140005a01" + }, + { + "address": "0x1400059f5", + "size": 5, + "mnemonic": "btr", + "operands": "rax, 0x18" + }, + { + "address": "0x1400059fa", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x2b68f], rax" + }, + { + "address": "0x140005a01", + "size": 5, + "mnemonic": "bt", + "operands": "r10d, 0x13" + }, + { + "address": "0x140005a06", + "size": 2, + "mnemonic": "jae", + "operands": "0x140005a52" + }, + { + "address": "0x140005a08", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x20]" + }, + { + "address": "0x140005a0d", + "size": 2, + "mnemonic": "and", + "operands": "al, dl" + }, + { + "address": "0x140005a0f", + "size": 2, + "mnemonic": "cmp", + "operands": "al, dl" + }, + { + "address": "0x140005a11", + "size": 2, + "mnemonic": "jne", + "operands": "0x140005a52" + }, + { + "address": "0x140005a13", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, r11d" + }, + { + "address": "0x140005a16", + "size": 3, + "mnemonic": "mov", + "operands": "eax, r11d" + }, + { + "address": "0x140005a19", + "size": 4, + "mnemonic": "shr", + "operands": "rcx, 0x10" + }, + { + "address": "0x140005a1d", + "size": 5, + "mnemonic": "and", + "operands": "eax, 0x400ff" + }, + { + "address": "0x140005a22", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 6" + }, + { + "address": "0x140005a25", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2cd0d], eax" + }, + { + "address": "0x140005a2b", + "size": 7, + "mnemonic": "or", + "operands": "rcx, 0x1000029" + }, + { + "address": "0x140005a32", + "size": 3, + "mnemonic": "not", + "operands": "rcx" + }, + { + "address": "0x140005a35", + "size": 7, + "mnemonic": "and", + "operands": "rcx, qword ptr [rip + 0x2b654]" + }, + { + "address": "0x140005a3c", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x2b64d], rcx" + }, + { + "address": "0x140005a43", + "size": 2, + "mnemonic": "cmp", + "operands": "al, 1" + }, + { + "address": "0x140005a45", + "size": 2, + "mnemonic": "jbe", + "operands": "0x140005a52" + }, + { + "address": "0x140005a47", + "size": 4, + "mnemonic": "and", + "operands": "rcx, 0xffffffffffffffbf" + }, + { + "address": "0x140005a4b", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x2b63e], rcx" + }, + { + "address": "0x140005a52", + "size": 5, + "mnemonic": "bt", + "operands": "r10d, 0x15" + }, + { + "address": "0x140005a57", + "size": 2, + "mnemonic": "jae", + "operands": "0x140005a6e" + }, + { + "address": "0x140005a59", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x20]" + }, + { + "address": "0x140005a5e", + "size": 5, + "mnemonic": "bt", + "operands": "rax, 0x13" + }, + { + "address": "0x140005a63", + "size": 2, + "mnemonic": "jae", + "operands": "0x140005a6e" + }, + { + "address": "0x140005a65", + "size": 9, + "mnemonic": "btr", + "operands": "qword ptr [rip + 0x2b622], 7" + }, + { + "address": "0x140005a6e", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x28]" + }, + { + "address": "0x140005a73", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140005a75", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140005a7a", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x38]" + }, + { + "address": "0x140005a7f", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x10" + }, + { + "address": "0x140005a83", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140005a84", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140005986", + "size": 20, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005986", + "size": 3, + "mnemonic": "or", + "operands": "eax, 0x20" + }, + { + "address": "0x140005989", + "size": 10, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2b705], 5" + }, + { + "address": "0x140005993", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2b703], eax" + }, + { + "address": "0x140005999", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0xd0030000" + }, + { + "address": "0x14000599e", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x2b6eb]" + }, + { + "address": "0x1400059a5", + "size": 3, + "mnemonic": "and", + "operands": "r9d, ecx" + }, + { + "address": "0x1400059a8", + "size": 4, + "mnemonic": "and", + "operands": "rax, 0xfffffffffffffffd" + }, + { + "address": "0x1400059ac", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x2b6dd], rax" + }, + { + "address": "0x1400059b3", + "size": 3, + "mnemonic": "cmp", + "operands": "r9d, ecx" + }, + { + "address": "0x1400059b6", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400059ef" + }, + { + "address": "0x1400059b8", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x20]" + }, + { + "address": "0x1400059bd", + "size": 2, + "mnemonic": "and", + "operands": "al, dl" + }, + { + "address": "0x1400059bf", + "size": 2, + "mnemonic": "cmp", + "operands": "al, dl" + }, + { + "address": "0x1400059c1", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400059e8" + }, + { + "address": "0x1400059c3", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x2b6c6]" + }, + { + "address": "0x1400059ca", + "size": 7, + "mnemonic": "or", + "operands": "dword ptr [rip + 0x2b6cb], 0x40" + }, + { + "address": "0x1400059d1", + "size": 4, + "mnemonic": "and", + "operands": "rax, 0xffffffffffffffdb" + }, + { + "address": "0x1400059d5", + "size": 10, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2b6b9], 6" + }, + { + "address": "0x1400059df", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x2b6aa], rax" + }, + { + "address": "0x1400059e6", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400059ef" + } + ], + "successors": [ + "0x1400059ef" + ] + }, + { + "address": "0x1400058d6", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400058d6", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x24" + }, + { + "address": "0x1400058db", + "size": 2, + "mnemonic": "cmp", + "operands": "ebp, eax" + }, + { + "address": "0x1400058dd", + "size": 2, + "mnemonic": "jl", + "operands": "0x1400058e6" + } + ], + "successors": [ + "0x1400058e6", + "0x1400058df" + ] + }, + { + "address": "0x1400058c9", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400058c9", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 7" + }, + { + "address": "0x1400058ce", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rax - 6]" + }, + { + "address": "0x1400058d1", + "size": 2, + "mnemonic": "cpuid", + "operands": "" + }, + { + "address": "0x1400058d3", + "size": 3, + "mnemonic": "mov", + "operands": "r10d, edx" + }, + { + "address": "0x1400058d6", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x24" + }, + { + "address": "0x1400058db", + "size": 2, + "mnemonic": "cmp", + "operands": "ebp, eax" + }, + { + "address": "0x1400058dd", + "size": 2, + "mnemonic": "jl", + "operands": "0x1400058e6" + } + ], + "successors": [ + "0x1400058e6", + "0x1400058df" + ] + }, + { + "address": "0x14000588e", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000588e", + "size": 7, + "mnemonic": "mov", + "operands": "r8d, dword ptr [rip + 0x2cea7]" + }, + { + "address": "0x140005895", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x140005898", + "size": 3, + "mnemonic": "mov", + "operands": "esi, r9d" + }, + { + "address": "0x14000589b", + "size": 3, + "mnemonic": "mov", + "operands": "r10d, r9d" + }, + { + "address": "0x14000589e", + "size": 3, + "mnemonic": "mov", + "operands": "r11d, r9d" + }, + { + "address": "0x1400058a1", + "size": 3, + "mnemonic": "cmp", + "operands": "ebp, 7" + }, + { + "address": "0x1400058a4", + "size": 2, + "mnemonic": "jl", + "operands": "0x1400058e6" + } + ], + "successors": [ + "0x1400058e6", + "0x1400058a6" + ] + }, + { + "address": "0x14000586a", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000586a", + "size": 10, + "mnemonic": "movabs", + "operands": "rcx, 0x100010001" + }, + { + "address": "0x140005874", + "size": 4, + "mnemonic": "bt", + "operands": "rcx, rax" + }, + { + "address": "0x140005878", + "size": 2, + "mnemonic": "jae", + "operands": "0x14000588e" + }, + { + "address": "0x14000587a", + "size": 7, + "mnemonic": "mov", + "operands": "r8d, dword ptr [rip + 0x2cebb]" + }, + { + "address": "0x140005881", + "size": 4, + "mnemonic": "or", + "operands": "r8d, 1" + }, + { + "address": "0x140005885", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2ceb0], r8d" + }, + { + "address": "0x14000588c", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140005895" + } + ], + "successors": [ + "0x140005895" + ] + }, + { + "address": "0x1400059ef", + "size": 37, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400059ef", + "size": 4, + "mnemonic": "bt", + "operands": "esi, 0x17" + }, + { + "address": "0x1400059f3", + "size": 2, + "mnemonic": "jae", + "operands": "0x140005a01" + }, + { + "address": "0x1400059f5", + "size": 5, + "mnemonic": "btr", + "operands": "rax, 0x18" + }, + { + "address": "0x1400059fa", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x2b68f], rax" + }, + { + "address": "0x140005a01", + "size": 5, + "mnemonic": "bt", + "operands": "r10d, 0x13" + }, + { + "address": "0x140005a06", + "size": 2, + "mnemonic": "jae", + "operands": "0x140005a52" + }, + { + "address": "0x140005a08", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x20]" + }, + { + "address": "0x140005a0d", + "size": 2, + "mnemonic": "and", + "operands": "al, dl" + }, + { + "address": "0x140005a0f", + "size": 2, + "mnemonic": "cmp", + "operands": "al, dl" + }, + { + "address": "0x140005a11", + "size": 2, + "mnemonic": "jne", + "operands": "0x140005a52" + }, + { + "address": "0x140005a13", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, r11d" + }, + { + "address": "0x140005a16", + "size": 3, + "mnemonic": "mov", + "operands": "eax, r11d" + }, + { + "address": "0x140005a19", + "size": 4, + "mnemonic": "shr", + "operands": "rcx, 0x10" + }, + { + "address": "0x140005a1d", + "size": 5, + "mnemonic": "and", + "operands": "eax, 0x400ff" + }, + { + "address": "0x140005a22", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 6" + }, + { + "address": "0x140005a25", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2cd0d], eax" + }, + { + "address": "0x140005a2b", + "size": 7, + "mnemonic": "or", + "operands": "rcx, 0x1000029" + }, + { + "address": "0x140005a32", + "size": 3, + "mnemonic": "not", + "operands": "rcx" + }, + { + "address": "0x140005a35", + "size": 7, + "mnemonic": "and", + "operands": "rcx, qword ptr [rip + 0x2b654]" + }, + { + "address": "0x140005a3c", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x2b64d], rcx" + }, + { + "address": "0x140005a43", + "size": 2, + "mnemonic": "cmp", + "operands": "al, 1" + }, + { + "address": "0x140005a45", + "size": 2, + "mnemonic": "jbe", + "operands": "0x140005a52" + }, + { + "address": "0x140005a47", + "size": 4, + "mnemonic": "and", + "operands": "rcx, 0xffffffffffffffbf" + }, + { + "address": "0x140005a4b", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x2b63e], rcx" + }, + { + "address": "0x140005a52", + "size": 5, + "mnemonic": "bt", + "operands": "r10d, 0x15" + }, + { + "address": "0x140005a57", + "size": 2, + "mnemonic": "jae", + "operands": "0x140005a6e" + }, + { + "address": "0x140005a59", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x20]" + }, + { + "address": "0x140005a5e", + "size": 5, + "mnemonic": "bt", + "operands": "rax, 0x13" + }, + { + "address": "0x140005a63", + "size": 2, + "mnemonic": "jae", + "operands": "0x140005a6e" + }, + { + "address": "0x140005a65", + "size": 9, + "mnemonic": "btr", + "operands": "qword ptr [rip + 0x2b622], 7" + }, + { + "address": "0x140005a6e", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x28]" + }, + { + "address": "0x140005a73", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140005a75", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140005a7a", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x38]" + }, + { + "address": "0x140005a7f", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x10" + }, + { + "address": "0x140005a83", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140005a84", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400058df", + "size": 34, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400058df", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x1400058e1", + "size": 2, + "mnemonic": "cpuid", + "operands": "" + }, + { + "address": "0x1400058e3", + "size": 3, + "mnemonic": "mov", + "operands": "r11d, ebx" + }, + { + "address": "0x1400058e6", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x2b7a3]" + }, + { + "address": "0x1400058ed", + "size": 4, + "mnemonic": "and", + "operands": "rax, 0xfffffffffffffffe" + }, + { + "address": "0x1400058f1", + "size": 10, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2b79d], 1" + }, + { + "address": "0x1400058fb", + "size": 10, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2b797], 2" + }, + { + "address": "0x140005905", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x2b784], rax" + }, + { + "address": "0x14000590c", + "size": 4, + "mnemonic": "bt", + "operands": "edi, 0x14" + }, + { + "address": "0x140005910", + "size": 2, + "mnemonic": "jae", + "operands": "0x140005931" + }, + { + "address": "0x140005912", + "size": 4, + "mnemonic": "and", + "operands": "rax, 0xffffffffffffffef" + }, + { + "address": "0x140005916", + "size": 10, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2b778], 2" + }, + { + "address": "0x140005920", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x2b769], rax" + }, + { + "address": "0x140005927", + "size": 10, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2b76b], 6" + }, + { + "address": "0x140005931", + "size": 4, + "mnemonic": "bt", + "operands": "edi, 0x1b" + }, + { + "address": "0x140005935", + "size": 6, + "mnemonic": "jae", + "operands": "0x140005a6e" + }, + { + "address": "0x14000593b", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14000593d", + "size": 3, + "mnemonic": "xgetbv", + "operands": "" + }, + { + "address": "0x140005940", + "size": 4, + "mnemonic": "shl", + "operands": "rdx, 0x20" + }, + { + "address": "0x140005944", + "size": 3, + "mnemonic": "or", + "operands": "rdx, rax" + }, + { + "address": "0x140005947", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rdx" + }, + { + "address": "0x14000594c", + "size": 4, + "mnemonic": "bt", + "operands": "edi, 0x1c" + }, + { + "address": "0x140005950", + "size": 6, + "mnemonic": "jae", + "operands": "0x140005a52" + }, + { + "address": "0x140005956", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x20]" + }, + { + "address": "0x14000595b", + "size": 2, + "mnemonic": "and", + "operands": "al, 6" + }, + { + "address": "0x14000595d", + "size": 2, + "mnemonic": "cmp", + "operands": "al, 6" + }, + { + "address": "0x14000595f", + "size": 6, + "mnemonic": "jne", + "operands": "0x140005a52" + }, + { + "address": "0x140005965", + "size": 6, + "mnemonic": "mov", + "operands": "eax, dword ptr [rip + 0x2b731]" + }, + { + "address": "0x14000596b", + "size": 2, + "mnemonic": "mov", + "operands": "dl, 0xe0" + }, + { + "address": "0x14000596d", + "size": 3, + "mnemonic": "or", + "operands": "eax, 8" + }, + { + "address": "0x140005970", + "size": 10, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2b71e], 3" + }, + { + "address": "0x14000597a", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2b71c], eax" + }, + { + "address": "0x140005980", + "size": 4, + "mnemonic": "test", + "operands": "r9b, 0x20" + }, + { + "address": "0x140005984", + "size": 2, + "mnemonic": "je", + "operands": "0x1400059e8" + } + ], + "successors": [ + "0x1400059e8", + "0x140005986" + ] + } + ] + }, + { + "address": "0x140007318", + "name": "", + "blocks": [ + { + "address": "0x140007318", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007318", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000731c", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a73c" + }, + { + "address": "0x140007321", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x140007323", + "size": 2, + "mnemonic": "jne", + "operands": "0x140007329" + }, + { + "address": "0x140007325", + "size": 2, + "mnemonic": "xor", + "operands": "al, al" + }, + { + "address": "0x140007327", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000733b" + } + ], + "successors": [ + "0x14000733b" + ] + }, + { + "address": "0x14000733b", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000733b", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000733f", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140010b38", + "name": "", + "blocks": [ + { + "address": "0x140010b38", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010b38", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x140010b3c", + "size": 2, + "mnemonic": "test", + "operands": "cl, cl" + }, + { + "address": "0x140010b3e", + "size": 2, + "mnemonic": "je", + "operands": "0x140010b56" + } + ], + "successors": [ + "0x140010b56", + "0x140010b40" + ] + }, + { + "address": "0x140010b56", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010b56", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x150c3]" + }, + { + "address": "0x140010b5d", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x14fbc]" + }, + { + "address": "0x140010b64", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x140010b68", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14001bff8" + } + ], + "successors": [ + "0x14001bff8" + ] + }, + { + "address": "0x140010b40", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010b40", + "size": 8, + "mnemonic": "cmp", + "operands": "qword ptr [rip + 0x222a0], 0" + }, + { + "address": "0x140010b48", + "size": 2, + "mnemonic": "je", + "operands": "0x140010b4f" + } + ], + "successors": [ + "0x140010b4f", + "0x140010b4a" + ] + }, + { + "address": "0x14001bff8", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bff8", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14001bffd", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001bffe", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001c002", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdx" + }, + { + "address": "0x14001c005", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x14001c008", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, rdx" + }, + { + "address": "0x14001c00b", + "size": 2, + "mnemonic": "je", + "operands": "0x14001c026" + } + ], + "successors": [ + "0x14001c026", + "0x14001c00d" + ] + }, + { + "address": "0x140010b4f", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140010b4f", + "size": 2, + "mnemonic": "mov", + "operands": "al, 1" + }, + { + "address": "0x140010b51", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x140010b55", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140010b4a", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140010b4a", + "size": 5, + "mnemonic": "call", + "operands": "0x14000b74c" + }, + { + "address": "0x140010b4f", + "size": 2, + "mnemonic": "mov", + "operands": "al, 1" + }, + { + "address": "0x140010b51", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x140010b55", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001c026", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001c026", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001c02b", + "size": 2, + "mnemonic": "mov", + "operands": "al, 1" + }, + { + "address": "0x14001c02d", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001c031", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001c032", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001c00d", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c00d", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx - 8]" + }, + { + "address": "0x14001c011", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001c014", + "size": 2, + "mnemonic": "je", + "operands": "0x14001c01d" + } + ], + "successors": [ + "0x14001c01d", + "0x14001c016" + ] + }, + { + "address": "0x14001c01d", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001c01d", + "size": 4, + "mnemonic": "sub", + "operands": "rbx, 0x10" + }, + { + "address": "0x14001c021", + "size": 3, + "mnemonic": "cmp", + "operands": "rbx, rdi" + }, + { + "address": "0x14001c024", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001c00d" + }, + { + "address": "0x14001c026", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001c02b", + "size": 2, + "mnemonic": "mov", + "operands": "al, 1" + }, + { + "address": "0x14001c02d", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001c031", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001c032", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001c016", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001c016", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14001c018", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3a0" + }, + { + "address": "0x14001c01d", + "size": 4, + "mnemonic": "sub", + "operands": "rbx, 0x10" + }, + { + "address": "0x14001c021", + "size": 3, + "mnemonic": "cmp", + "operands": "rbx, rdi" + }, + { + "address": "0x14001c024", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001c00d" + }, + { + "address": "0x14001c026", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001c02b", + "size": 2, + "mnemonic": "mov", + "operands": "al, 1" + }, + { + "address": "0x14001c02d", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001c031", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001c032", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140007340", + "name": "", + "blocks": [ + { + "address": "0x140007340", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140007340", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x140007344", + "size": 2, + "mnemonic": "test", + "operands": "cl, cl" + }, + { + "address": "0x140007346", + "size": 2, + "mnemonic": "jne", + "operands": "0x140007352" + }, + { + "address": "0x140007348", + "size": 5, + "mnemonic": "call", + "operands": "0x140007514" + }, + { + "address": "0x14000734d", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a784" + }, + { + "address": "0x140007352", + "size": 2, + "mnemonic": "mov", + "operands": "al, 1" + }, + { + "address": "0x140007354", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x140007358", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140005e38", + "name": "", + "blocks": [ + { + "address": "0x140005e38", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140005e38", + "size": 10, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x2ce86], 0" + }, + { + "address": "0x140005e42", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001ea80", + "name": "", + "blocks": [ + { + "address": "0x14001ea80", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ea80", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rcx" + }, + { + "address": "0x14001ea83", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rcx" + }, + { + "address": "0x14001ea86", + "size": 7, + "mnemonic": "lea", + "operands": "r10, [rip - 0x1ea8d]" + }, + { + "address": "0x14001ea8d", + "size": 3, + "mnemonic": "movzx", + "operands": "edx, dl" + }, + { + "address": "0x14001ea90", + "size": 10, + "mnemonic": "movabs", + "operands": "r11, 0x101010101010101" + }, + { + "address": "0x14001ea9a", + "size": 4, + "mnemonic": "imul", + "operands": "r11, rdx" + }, + { + "address": "0x14001ea9e", + "size": 5, + "mnemonic": "movq", + "operands": "xmm0, r11" + }, + { + "address": "0x14001eaa3", + "size": 4, + "mnemonic": "cmp", + "operands": "r8, 0xf" + }, + { + "address": "0x14001eaa7", + "size": 6, + "mnemonic": "ja", + "operands": "0x14001eb30" + } + ], + "successors": [ + "0x14001eb30", + "0x14001eaad" + ] + }, + { + "address": "0x14001eb30", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001eb30", + "size": 4, + "mnemonic": "punpcklqdq", + "operands": "xmm0, xmm0" + }, + { + "address": "0x14001eb34", + "size": 4, + "mnemonic": "cmp", + "operands": "r8, 0x20" + }, + { + "address": "0x14001eb38", + "size": 2, + "mnemonic": "ja", + "operands": "0x14001eb46" + } + ], + "successors": [ + "0x14001eb46", + "0x14001eb3a" + ] + }, + { + "address": "0x14001eaad", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001eaad", + "size": 3, + "mnemonic": "nop", + "operands": "dword ptr [rax]" + }, + { + "address": "0x14001eab0", + "size": 3, + "mnemonic": "add", + "operands": "rcx, r8" + }, + { + "address": "0x14001eab3", + "size": 8, + "mnemonic": "mov", + "operands": "r9d, dword ptr [r10 + r8*4 + 0x2cac0]" + }, + { + "address": "0x14001eabb", + "size": 3, + "mnemonic": "add", + "operands": "r9, r10" + }, + { + "address": "0x14001eabe", + "size": 3, + "mnemonic": "jmp", + "operands": "r9" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001eb46", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001eb46", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x1254b], 3" + }, + { + "address": "0x14001eb4d", + "size": 6, + "mnemonic": "jb", + "operands": "0x14001ed30" + } + ], + "successors": [ + "0x14001ed30", + "0x14001eb53" + ] + }, + { + "address": "0x14001eb3a", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001eb3a", + "size": 4, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rcx], xmm0" + }, + { + "address": "0x14001eb3e", + "size": 7, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rcx + r8 - 0x10], xmm0" + }, + { + "address": "0x14001eb45", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001ed30", + "size": 32, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ed30", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, qword ptr [rip + 0x12369]" + }, + { + "address": "0x14001ed37", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14001ed46" + }, + { + "address": "0x14001ed39", + "size": 7, + "mnemonic": "test", + "operands": "byte ptr [rip + 0x139fc], 2" + }, + { + "address": "0x14001ed40", + "size": 6, + "mnemonic": "jne", + "operands": "0x14001ea70" + }, + { + "address": "0x14001ed46", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rcx" + }, + { + "address": "0x14001ed49", + "size": 4, + "mnemonic": "and", + "operands": "r9, 0xf" + }, + { + "address": "0x14001ed4d", + "size": 4, + "mnemonic": "sub", + "operands": "r9, 0x10" + }, + { + "address": "0x14001ed51", + "size": 3, + "mnemonic": "sub", + "operands": "rcx, r9" + }, + { + "address": "0x14001ed54", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x14001ed57", + "size": 3, + "mnemonic": "add", + "operands": "r8, r9" + }, + { + "address": "0x14001ed5a", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x80" + }, + { + "address": "0x14001ed61", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14001edae" + }, + { + "address": "0x14001ed63", + "size": 13, + "mnemonic": "nop", + "operands": "word ptr [rax + rax]" + }, + { + "address": "0x14001ed70", + "size": 4, + "mnemonic": "movdqa", + "operands": "xmmword ptr [rcx], xmm0" + }, + { + "address": "0x14001ed74", + "size": 5, + "mnemonic": "movdqa", + "operands": "xmmword ptr [rcx + 0x10], xmm0" + }, + { + "address": "0x14001ed79", + "size": 5, + "mnemonic": "movdqa", + "operands": "xmmword ptr [rcx + 0x20], xmm0" + }, + { + "address": "0x14001ed7e", + "size": 5, + "mnemonic": "movdqa", + "operands": "xmmword ptr [rcx + 0x30], xmm0" + }, + { + "address": "0x14001ed83", + "size": 5, + "mnemonic": "movdqa", + "operands": "xmmword ptr [rcx + 0x40], xmm0" + }, + { + "address": "0x14001ed88", + "size": 5, + "mnemonic": "movdqa", + "operands": "xmmword ptr [rcx + 0x50], xmm0" + }, + { + "address": "0x14001ed8d", + "size": 5, + "mnemonic": "movdqa", + "operands": "xmmword ptr [rcx + 0x60], xmm0" + }, + { + "address": "0x14001ed92", + "size": 5, + "mnemonic": "movdqa", + "operands": "xmmword ptr [rcx + 0x70], xmm0" + }, + { + "address": "0x14001ed97", + "size": 7, + "mnemonic": "add", + "operands": "rcx, 0x80" + }, + { + "address": "0x14001ed9e", + "size": 7, + "mnemonic": "sub", + "operands": "r8, 0x80" + }, + { + "address": "0x14001eda5", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x80" + }, + { + "address": "0x14001edac", + "size": 2, + "mnemonic": "jae", + "operands": "0x14001ed70" + }, + { + "address": "0x14001edae", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [r8 + 0xf]" + }, + { + "address": "0x14001edb2", + "size": 4, + "mnemonic": "and", + "operands": "r9, 0xfffffffffffffff0" + }, + { + "address": "0x14001edb6", + "size": 3, + "mnemonic": "mov", + "operands": "r11, r9" + }, + { + "address": "0x14001edb9", + "size": 4, + "mnemonic": "shr", + "operands": "r11, 4" + }, + { + "address": "0x14001edbd", + "size": 8, + "mnemonic": "mov", + "operands": "r11d, dword ptr [r10 + r11*4 + 0x2cb48]" + }, + { + "address": "0x14001edc5", + "size": 3, + "mnemonic": "add", + "operands": "r11, r10" + }, + { + "address": "0x14001edc8", + "size": 3, + "mnemonic": "jmp", + "operands": "r11" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001eb53", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001eb53", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, qword ptr [rip + 0x12546]" + }, + { + "address": "0x14001eb5a", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14001eb72" + }, + { + "address": "0x14001eb5c", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, qword ptr [rip + 0x12545]" + }, + { + "address": "0x14001eb63", + "size": 2, + "mnemonic": "ja", + "operands": "0x14001eb72" + } + ], + "successors": [ + "0x14001eb72", + "0x14001eb65" + ] + }, + { + "address": "0x14001eb72", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001eb72", + "size": 6, + "mnemonic": "vinsertf128", + "operands": "ymm0, ymm0, xmm0, 1" + }, + { + "address": "0x14001eb78", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rcx" + }, + { + "address": "0x14001eb7b", + "size": 4, + "mnemonic": "and", + "operands": "r9, 0x1f" + }, + { + "address": "0x14001eb7f", + "size": 4, + "mnemonic": "sub", + "operands": "r9, 0x20" + }, + { + "address": "0x14001eb83", + "size": 3, + "mnemonic": "sub", + "operands": "rcx, r9" + }, + { + "address": "0x14001eb86", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x14001eb89", + "size": 3, + "mnemonic": "add", + "operands": "r8, r9" + }, + { + "address": "0x14001eb8c", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x100" + }, + { + "address": "0x14001eb93", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14001ebfa" + }, + { + "address": "0x14001eb95", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, qword ptr [rip + 0x1250c]" + }, + { + "address": "0x14001eb9c", + "size": 6, + "mnemonic": "ja", + "operands": "0x14001ec70" + } + ], + "successors": [ + "0x14001ec70", + "0x14001eba2" + ] + }, + { + "address": "0x14001eb65", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001eb65", + "size": 7, + "mnemonic": "test", + "operands": "byte ptr [rip + 0x13bd0], 2" + }, + { + "address": "0x14001eb6c", + "size": 6, + "mnemonic": "jne", + "operands": "0x14001ea70" + }, + { + "address": "0x14001eb72", + "size": 6, + "mnemonic": "vinsertf128", + "operands": "ymm0, ymm0, xmm0, 1" + }, + { + "address": "0x14001eb78", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rcx" + }, + { + "address": "0x14001eb7b", + "size": 4, + "mnemonic": "and", + "operands": "r9, 0x1f" + }, + { + "address": "0x14001eb7f", + "size": 4, + "mnemonic": "sub", + "operands": "r9, 0x20" + }, + { + "address": "0x14001eb83", + "size": 3, + "mnemonic": "sub", + "operands": "rcx, r9" + }, + { + "address": "0x14001eb86", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x14001eb89", + "size": 3, + "mnemonic": "add", + "operands": "r8, r9" + }, + { + "address": "0x14001eb8c", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x100" + }, + { + "address": "0x14001eb93", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14001ebfa" + }, + { + "address": "0x14001eb95", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, qword ptr [rip + 0x1250c]" + }, + { + "address": "0x14001eb9c", + "size": 6, + "mnemonic": "ja", + "operands": "0x14001ec70" + } + ], + "successors": [ + "0x14001ec70", + "0x14001eba2" + ] + }, + { + "address": "0x14001ec70", + "size": 19, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ec70", + "size": 4, + "mnemonic": "vmovntdq", + "operands": "ymmword ptr [rcx], ymm0" + }, + { + "address": "0x14001ec74", + "size": 5, + "mnemonic": "vmovntdq", + "operands": "ymmword ptr [rcx + 0x20], ymm0" + }, + { + "address": "0x14001ec79", + "size": 5, + "mnemonic": "vmovntdq", + "operands": "ymmword ptr [rcx + 0x40], ymm0" + }, + { + "address": "0x14001ec7e", + "size": 5, + "mnemonic": "vmovntdq", + "operands": "ymmword ptr [rcx + 0x60], ymm0" + }, + { + "address": "0x14001ec83", + "size": 8, + "mnemonic": "vmovntdq", + "operands": "ymmword ptr [rcx + 0x80], ymm0" + }, + { + "address": "0x14001ec8b", + "size": 8, + "mnemonic": "vmovntdq", + "operands": "ymmword ptr [rcx + 0xa0], ymm0" + }, + { + "address": "0x14001ec93", + "size": 8, + "mnemonic": "vmovntdq", + "operands": "ymmword ptr [rcx + 0xc0], ymm0" + }, + { + "address": "0x14001ec9b", + "size": 8, + "mnemonic": "vmovntdq", + "operands": "ymmword ptr [rcx + 0xe0], ymm0" + }, + { + "address": "0x14001eca3", + "size": 7, + "mnemonic": "add", + "operands": "rcx, 0x100" + }, + { + "address": "0x14001ecaa", + "size": 7, + "mnemonic": "sub", + "operands": "r8, 0x100" + }, + { + "address": "0x14001ecb1", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x100" + }, + { + "address": "0x14001ecb8", + "size": 2, + "mnemonic": "jae", + "operands": "0x14001ec70" + }, + { + "address": "0x14001ecba", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [r8 + 0x1f]" + }, + { + "address": "0x14001ecbe", + "size": 4, + "mnemonic": "and", + "operands": "r9, 0xffffffffffffffe0" + }, + { + "address": "0x14001ecc2", + "size": 3, + "mnemonic": "mov", + "operands": "r11, r9" + }, + { + "address": "0x14001ecc5", + "size": 4, + "mnemonic": "shr", + "operands": "r11, 5" + }, + { + "address": "0x14001ecc9", + "size": 8, + "mnemonic": "mov", + "operands": "r11d, dword ptr [r10 + r11*4 + 0x2cb24]" + }, + { + "address": "0x14001ecd1", + "size": 3, + "mnemonic": "add", + "operands": "r11, r10" + }, + { + "address": "0x14001ecd4", + "size": 3, + "mnemonic": "jmp", + "operands": "r11" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001eba2", + "size": 20, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001eba2", + "size": 14, + "mnemonic": "nop", + "operands": "word ptr [rax + rax]" + }, + { + "address": "0x14001ebb0", + "size": 4, + "mnemonic": "vmovdqa", + "operands": "ymmword ptr [rcx], ymm0" + }, + { + "address": "0x14001ebb4", + "size": 5, + "mnemonic": "vmovdqa", + "operands": "ymmword ptr [rcx + 0x20], ymm0" + }, + { + "address": "0x14001ebb9", + "size": 5, + "mnemonic": "vmovdqa", + "operands": "ymmword ptr [rcx + 0x40], ymm0" + }, + { + "address": "0x14001ebbe", + "size": 5, + "mnemonic": "vmovdqa", + "operands": "ymmword ptr [rcx + 0x60], ymm0" + }, + { + "address": "0x14001ebc3", + "size": 8, + "mnemonic": "vmovdqa", + "operands": "ymmword ptr [rcx + 0x80], ymm0" + }, + { + "address": "0x14001ebcb", + "size": 8, + "mnemonic": "vmovdqa", + "operands": "ymmword ptr [rcx + 0xa0], ymm0" + }, + { + "address": "0x14001ebd3", + "size": 8, + "mnemonic": "vmovdqa", + "operands": "ymmword ptr [rcx + 0xc0], ymm0" + }, + { + "address": "0x14001ebdb", + "size": 8, + "mnemonic": "vmovdqa", + "operands": "ymmword ptr [rcx + 0xe0], ymm0" + }, + { + "address": "0x14001ebe3", + "size": 7, + "mnemonic": "add", + "operands": "rcx, 0x100" + }, + { + "address": "0x14001ebea", + "size": 7, + "mnemonic": "sub", + "operands": "r8, 0x100" + }, + { + "address": "0x14001ebf1", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x100" + }, + { + "address": "0x14001ebf8", + "size": 2, + "mnemonic": "jae", + "operands": "0x14001ebb0" + }, + { + "address": "0x14001ebfa", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [r8 + 0x1f]" + }, + { + "address": "0x14001ebfe", + "size": 4, + "mnemonic": "and", + "operands": "r9, 0xffffffffffffffe0" + }, + { + "address": "0x14001ec02", + "size": 3, + "mnemonic": "mov", + "operands": "r11, r9" + }, + { + "address": "0x14001ec05", + "size": 4, + "mnemonic": "shr", + "operands": "r11, 5" + }, + { + "address": "0x14001ec09", + "size": 8, + "mnemonic": "mov", + "operands": "r11d, dword ptr [r10 + r11*4 + 0x2cb00]" + }, + { + "address": "0x14001ec11", + "size": 3, + "mnemonic": "add", + "operands": "r11, r10" + }, + { + "address": "0x14001ec14", + "size": 3, + "mnemonic": "jmp", + "operands": "r11" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001e3a0", + "name": "", + "blocks": [ + { + "address": "0x14001e3a0", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e3a0", + "size": 6, + "mnemonic": "jmp", + "operands": "qword ptr [rip + 0x1f1a]" + } + ], + "successors": [ + "0x14001e360" + ] + } + ] + }, + { + "address": "0x14000e934", + "name": "", + "blocks": [ + { + "address": "0x14000e934", + "size": 18, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000e934", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000e939", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r9" + }, + { + "address": "0x14000e93e", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000e93f", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000e943", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r9" + }, + { + "address": "0x14000e946", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r8" + }, + { + "address": "0x14000e949", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rdx]" + }, + { + "address": "0x14000e94b", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca20" + }, + { + "address": "0x14000e950", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14000e951", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x14000e954", + "size": 5, + "mnemonic": "call", + "operands": "0x14000e96c" + }, + { + "address": "0x14000e959", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14000e95a", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbx]" + }, + { + "address": "0x14000e95c", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca74" + }, + { + "address": "0x14000e961", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000e966", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000e96a", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000e96b", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400191c0", + "name": "", + "blocks": [ + { + "address": "0x1400191c0", + "size": 15, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400191c0", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x1400191c2", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400191c6", + "size": 2, + "mnemonic": "xor", + "operands": "ebx, ebx" + }, + { + "address": "0x1400191c8", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x30], ebx" + }, + { + "address": "0x1400191cc", + "size": 5, + "mnemonic": "call", + "operands": "0x1400191a8" + }, + { + "address": "0x1400191d1", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x1400191d3", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400191df" + }, + { + "address": "0x1400191d5", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x30]" + }, + { + "address": "0x1400191da", + "size": 5, + "mnemonic": "call", + "operands": "0x140011db4" + }, + { + "address": "0x1400191df", + "size": 5, + "mnemonic": "cmp", + "operands": "dword ptr [rsp + 0x30], 1" + }, + { + "address": "0x1400191e4", + "size": 3, + "mnemonic": "setne", + "operands": "bl" + }, + { + "address": "0x1400191e7", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ebx" + }, + { + "address": "0x1400191e9", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400191ed", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x1400191ee", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000eb40", + "name": "", + "blocks": [ + { + "address": "0x14000eb40", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000eb40", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x14000eb42", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000eb46", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], 0xfffffffffffffffe" + }, + { + "address": "0x14000eb4f", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, ecx" + }, + { + "address": "0x14000eb51", + "size": 6, + "mnemonic": "and", + "operands": "qword ptr [rsp + 0x48], 0" + }, + { + "address": "0x14000eb57", + "size": 5, + "mnemonic": "lea", + "operands": "r8, [rsp + 0x48]" + }, + { + "address": "0x14000eb5c", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x16d9d]" + }, + { + "address": "0x14000eb63", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14000eb65", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x115fd]" + }, + { + "address": "0x14000eb6b", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14000eb70", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000eb72", + "size": 2, + "mnemonic": "je", + "operands": "0x14000eb92" + } + ], + "successors": [ + "0x14000eb92", + "0x14000eb74" + ] + }, + { + "address": "0x14000eb92", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000eb92", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14000eb95", + "size": 2, + "mnemonic": "je", + "operands": "0x14000eb9e" + } + ], + "successors": [ + "0x14000eb9e", + "0x14000eb97" + ] + }, + { + "address": "0x14000eb74", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000eb74", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x16d9d]" + }, + { + "address": "0x14000eb7b", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x115b7]" + }, + { + "address": "0x14000eb81", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000eb84", + "size": 2, + "mnemonic": "je", + "operands": "0x14000eb8d" + } + ], + "successors": [ + "0x14000eb8d", + "0x14000eb86" + ] + }, + { + "address": "0x14000eb9e", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000eb9e", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000eba2", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000eba3", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000eb97", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000eb97", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x11593]" + }, + { + "address": "0x14000eb9d", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14000eb9e", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000eba2", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000eba3", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000eb8d", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000eb8d", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14000eb92", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14000eb95", + "size": 2, + "mnemonic": "je", + "operands": "0x14000eb9e" + } + ], + "successors": [ + "0x14000eb9e", + "0x14000eb97" + ] + }, + { + "address": "0x14000eb86", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000eb86", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x14000eb88", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3a0" + }, + { + "address": "0x14000eb8d", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14000eb92", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14000eb95", + "size": 2, + "mnemonic": "je", + "operands": "0x14000eb9e" + } + ], + "successors": [ + "0x14000eb9e", + "0x14000eb97" + ] + } + ] + }, + { + "address": "0x14000eb10", + "name": "", + "blocks": [ + { + "address": "0x14000eb10", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000eb10", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x14000eb12", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000eb16", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, ecx" + }, + { + "address": "0x14000eb18", + "size": 2, + "mnemonic": "test", + "operands": "dl, dl" + }, + { + "address": "0x14000eb1a", + "size": 2, + "mnemonic": "je", + "operands": "0x14000eb2d" + } + ], + "successors": [ + "0x14000eb2d", + "0x14000eb1c" + ] + }, + { + "address": "0x14000eb2d", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000eb2d", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x14000eb2f", + "size": 5, + "mnemonic": "call", + "operands": "0x14000eb40" + }, + { + "address": "0x14000eb34", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x14000eb36", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x11624]" + }, + { + "address": "0x14000eb3c", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000eb1c", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000eb1c", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1155e]" + }, + { + "address": "0x14000eb22", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x14000eb25", + "size": 2, + "mnemonic": "mov", + "operands": "edx, ebx" + }, + { + "address": "0x14000eb27", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1155b]" + }, + { + "address": "0x14000eb2d", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x14000eb2f", + "size": 5, + "mnemonic": "call", + "operands": "0x14000eb40" + }, + { + "address": "0x14000eb34", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x14000eb36", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x11624]" + }, + { + "address": "0x14000eb3c", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001ef10", + "name": "", + "blocks": [ + { + "address": "0x14001ef10", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ef10", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rcx" + }, + { + "address": "0x14001ef13", + "size": 3, + "mnemonic": "neg", + "operands": "rcx" + }, + { + "address": "0x14001ef16", + "size": 6, + "mnemonic": "test", + "operands": "rax, 7" + }, + { + "address": "0x14001ef1c", + "size": 2, + "mnemonic": "je", + "operands": "0x14001ef2d" + } + ], + "successors": [ + "0x14001ef2d", + "0x14001ef1e" + ] + }, + { + "address": "0x14001ef2d", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ef2d", + "size": 10, + "mnemonic": "movabs", + "operands": "r8, 0x7efefefefefefeff" + }, + { + "address": "0x14001ef37", + "size": 10, + "mnemonic": "movabs", + "operands": "r11, 0x8101010101010100" + }, + { + "address": "0x14001ef41", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rax]" + }, + { + "address": "0x14001ef44", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r8" + }, + { + "address": "0x14001ef47", + "size": 4, + "mnemonic": "add", + "operands": "rax, 8" + }, + { + "address": "0x14001ef4b", + "size": 3, + "mnemonic": "add", + "operands": "r9, rdx" + }, + { + "address": "0x14001ef4e", + "size": 3, + "mnemonic": "not", + "operands": "rdx" + }, + { + "address": "0x14001ef51", + "size": 3, + "mnemonic": "xor", + "operands": "rdx, r9" + }, + { + "address": "0x14001ef54", + "size": 3, + "mnemonic": "and", + "operands": "rdx, r11" + }, + { + "address": "0x14001ef57", + "size": 2, + "mnemonic": "je", + "operands": "0x14001ef41" + } + ], + "successors": [ + "0x14001ef41", + "0x14001ef59" + ] + }, + { + "address": "0x14001ef1e", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ef1e", + "size": 2, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14001ef20", + "size": 2, + "mnemonic": "mov", + "operands": "dl, byte ptr [rax]" + }, + { + "address": "0x14001ef22", + "size": 3, + "mnemonic": "inc", + "operands": "rax" + }, + { + "address": "0x14001ef25", + "size": 2, + "mnemonic": "test", + "operands": "dl, dl" + }, + { + "address": "0x14001ef27", + "size": 2, + "mnemonic": "je", + "operands": "0x14001ef88" + } + ], + "successors": [ + "0x14001ef88", + "0x14001ef29" + ] + }, + { + "address": "0x14001ef41", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ef41", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rax]" + }, + { + "address": "0x14001ef44", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r8" + }, + { + "address": "0x14001ef47", + "size": 4, + "mnemonic": "add", + "operands": "rax, 8" + }, + { + "address": "0x14001ef4b", + "size": 3, + "mnemonic": "add", + "operands": "r9, rdx" + }, + { + "address": "0x14001ef4e", + "size": 3, + "mnemonic": "not", + "operands": "rdx" + }, + { + "address": "0x14001ef51", + "size": 3, + "mnemonic": "xor", + "operands": "rdx, r9" + }, + { + "address": "0x14001ef54", + "size": 3, + "mnemonic": "and", + "operands": "rdx, r11" + }, + { + "address": "0x14001ef57", + "size": 2, + "mnemonic": "je", + "operands": "0x14001ef41" + } + ], + "successors": [ + "0x14001ef41", + "0x14001ef59" + ] + }, + { + "address": "0x14001ef59", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ef59", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rax - 8]" + }, + { + "address": "0x14001ef5d", + "size": 2, + "mnemonic": "test", + "operands": "dl, dl" + }, + { + "address": "0x14001ef5f", + "size": 2, + "mnemonic": "je", + "operands": "0x14001efb2" + } + ], + "successors": [ + "0x14001efb2", + "0x14001ef61" + ] + }, + { + "address": "0x14001ef88", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001ef88", + "size": 5, + "mnemonic": "lea", + "operands": "rax, [rax + rcx - 1]" + }, + { + "address": "0x14001ef8d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001ef29", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ef29", + "size": 2, + "mnemonic": "test", + "operands": "al, 7" + }, + { + "address": "0x14001ef2b", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001ef20" + }, + { + "address": "0x14001ef2d", + "size": 10, + "mnemonic": "movabs", + "operands": "r8, 0x7efefefefefefeff" + }, + { + "address": "0x14001ef37", + "size": 10, + "mnemonic": "movabs", + "operands": "r11, 0x8101010101010100" + }, + { + "address": "0x14001ef41", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rax]" + }, + { + "address": "0x14001ef44", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r8" + }, + { + "address": "0x14001ef47", + "size": 4, + "mnemonic": "add", + "operands": "rax, 8" + }, + { + "address": "0x14001ef4b", + "size": 3, + "mnemonic": "add", + "operands": "r9, rdx" + }, + { + "address": "0x14001ef4e", + "size": 3, + "mnemonic": "not", + "operands": "rdx" + }, + { + "address": "0x14001ef51", + "size": 3, + "mnemonic": "xor", + "operands": "rdx, r9" + }, + { + "address": "0x14001ef54", + "size": 3, + "mnemonic": "and", + "operands": "rdx, r11" + }, + { + "address": "0x14001ef57", + "size": 2, + "mnemonic": "je", + "operands": "0x14001ef41" + } + ], + "successors": [ + "0x14001ef41", + "0x14001ef59" + ] + }, + { + "address": "0x14001efb2", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001efb2", + "size": 5, + "mnemonic": "lea", + "operands": "rax, [rax + rcx - 8]" + }, + { + "address": "0x14001efb7", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001ef61", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ef61", + "size": 2, + "mnemonic": "test", + "operands": "dh, dh" + }, + { + "address": "0x14001ef63", + "size": 2, + "mnemonic": "je", + "operands": "0x14001efac" + } + ], + "successors": [ + "0x14001efac", + "0x14001ef65" + ] + }, + { + "address": "0x14001efac", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001efac", + "size": 5, + "mnemonic": "lea", + "operands": "rax, [rax + rcx - 7]" + }, + { + "address": "0x14001efb1", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001ef65", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ef65", + "size": 4, + "mnemonic": "shr", + "operands": "rdx, 0x10" + }, + { + "address": "0x14001ef69", + "size": 2, + "mnemonic": "test", + "operands": "dl, dl" + }, + { + "address": "0x14001ef6b", + "size": 2, + "mnemonic": "je", + "operands": "0x14001efa6" + } + ], + "successors": [ + "0x14001efa6", + "0x14001ef6d" + ] + }, + { + "address": "0x14001efa6", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001efa6", + "size": 5, + "mnemonic": "lea", + "operands": "rax, [rax + rcx - 6]" + }, + { + "address": "0x14001efab", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001ef6d", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ef6d", + "size": 2, + "mnemonic": "test", + "operands": "dh, dh" + }, + { + "address": "0x14001ef6f", + "size": 2, + "mnemonic": "je", + "operands": "0x14001efa0" + } + ], + "successors": [ + "0x14001efa0", + "0x14001ef71" + ] + }, + { + "address": "0x14001efa0", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001efa0", + "size": 5, + "mnemonic": "lea", + "operands": "rax, [rax + rcx - 5]" + }, + { + "address": "0x14001efa5", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001ef71", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ef71", + "size": 4, + "mnemonic": "shr", + "operands": "rdx, 0x10" + }, + { + "address": "0x14001ef75", + "size": 2, + "mnemonic": "test", + "operands": "dl, dl" + }, + { + "address": "0x14001ef77", + "size": 2, + "mnemonic": "je", + "operands": "0x14001ef9a" + } + ], + "successors": [ + "0x14001ef9a", + "0x14001ef79" + ] + }, + { + "address": "0x14001ef9a", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001ef9a", + "size": 5, + "mnemonic": "lea", + "operands": "rax, [rax + rcx - 4]" + }, + { + "address": "0x14001ef9f", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001ef79", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ef79", + "size": 2, + "mnemonic": "test", + "operands": "dh, dh" + }, + { + "address": "0x14001ef7b", + "size": 2, + "mnemonic": "je", + "operands": "0x14001ef94" + } + ], + "successors": [ + "0x14001ef94", + "0x14001ef7d" + ] + }, + { + "address": "0x14001ef94", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001ef94", + "size": 5, + "mnemonic": "lea", + "operands": "rax, [rax + rcx - 3]" + }, + { + "address": "0x14001ef99", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001ef7d", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ef7d", + "size": 3, + "mnemonic": "shr", + "operands": "edx, 0x10" + }, + { + "address": "0x14001ef80", + "size": 2, + "mnemonic": "test", + "operands": "dl, dl" + }, + { + "address": "0x14001ef82", + "size": 2, + "mnemonic": "je", + "operands": "0x14001ef8e" + } + ], + "successors": [ + "0x14001ef8e", + "0x14001ef84" + ] + }, + { + "address": "0x14001ef8e", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001ef8e", + "size": 5, + "mnemonic": "lea", + "operands": "rax, [rax + rcx - 2]" + }, + { + "address": "0x14001ef93", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001ef84", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001ef84", + "size": 2, + "mnemonic": "test", + "operands": "dh, dh" + }, + { + "address": "0x14001ef86", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001ef41" + }, + { + "address": "0x14001ef88", + "size": 5, + "mnemonic": "lea", + "operands": "rax, [rax + rcx - 1]" + }, + { + "address": "0x14001ef8d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140002000", + "name": "", + "blocks": [ + { + "address": "0x140002000", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140002000", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbx" + }, + { + "address": "0x140002005", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x14000200a", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rcx" + }, + { + "address": "0x14000200f", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140002010", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x70" + }, + { + "address": "0x140002014", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140002017", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x14000201a", + "size": 4, + "mnemonic": "movsxd", + "operands": "rdx, dword ptr [rax + 4]" + }, + { + "address": "0x14000201e", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rdx + rcx + 0x48]" + }, + { + "address": "0x140002023", + "size": 3, + "mnemonic": "test", + "operands": "rsi, rsi" + }, + { + "address": "0x140002026", + "size": 6, + "mnemonic": "je", + "operands": "0x1400020cc" + } + ], + "successors": [ + "0x1400020cc", + "0x14000202c" + ] + }, + { + "address": "0x1400020cc", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400020cc", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x1400020cf", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x70]" + }, + { + "address": "0x1400020d4", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x18]" + }, + { + "address": "0x1400020d8", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x20]" + }, + { + "address": "0x1400020dc", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x1400020df", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400020e0", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000202c", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000202c", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rcx" + }, + { + "address": "0x14000202f", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x28]" + }, + { + "address": "0x140002034", + "size": 5, + "mnemonic": "call", + "operands": "0x140001ab0" + }, + { + "address": "0x140002039", + "size": 5, + "mnemonic": "cmp", + "operands": "byte ptr [rsp + 0x30], 0" + }, + { + "address": "0x14000203e", + "size": 2, + "mnemonic": "je", + "operands": "0x14000209d" + } + ], + "successors": [ + "0x14000209d", + "0x140002040" + ] + }, + { + "address": "0x14000209d", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000209d", + "size": 5, + "mnemonic": "call", + "operands": "0x1400023f4" + }, + { + "address": "0x1400020a2", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x1400020a4", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400020b0" + }, + { + "address": "0x1400020a6", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x28]" + }, + { + "address": "0x1400020ab", + "size": 5, + "mnemonic": "call", + "operands": "0x140001d10" + }, + { + "address": "0x1400020b0", + "size": 5, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rsp + 0x28]" + }, + { + "address": "0x1400020b5", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdx]" + }, + { + "address": "0x1400020b8", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax + 4]" + }, + { + "address": "0x1400020bc", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + rdx + 0x48]" + }, + { + "address": "0x1400020c1", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x1400020c4", + "size": 2, + "mnemonic": "je", + "operands": "0x1400020cc" + } + ], + "successors": [ + "0x1400020cc", + "0x1400020c6" + ] + }, + { + "address": "0x140002040", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140002040", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x140002042", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x20], edi" + }, + { + "address": "0x140002046", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsi]" + }, + { + "address": "0x140002049", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x14000204c", + "size": 3, + "mnemonic": "call", + "operands": "qword ptr [rax + 0x68]" + }, + { + "address": "0x14000204f", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, edi" + }, + { + "address": "0x140002052", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 4" + }, + { + "address": "0x140002057", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, -1" + }, + { + "address": "0x14000205a", + "size": 4, + "mnemonic": "cmove", + "operands": "r8d, edx" + }, + { + "address": "0x14000205e", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x20], r8d" + }, + { + "address": "0x140002063", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140002079" + } + ], + "successors": [ + "0x140002079" + ] + }, + { + "address": "0x1400020c6", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400020c6", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x1400020c9", + "size": 3, + "mnemonic": "call", + "operands": "qword ptr [rax + 0x10]" + }, + { + "address": "0x1400020cc", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x1400020cf", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x70]" + }, + { + "address": "0x1400020d4", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x18]" + }, + { + "address": "0x1400020d8", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x20]" + }, + { + "address": "0x1400020dc", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x1400020df", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400020e0", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140002079", + "size": 21, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140002079", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx]" + }, + { + "address": "0x14000207c", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax + 4]" + }, + { + "address": "0x140002080", + "size": 6, + "mnemonic": "cmp", + "operands": "qword ptr [rcx + rbx + 0x48], 0" + }, + { + "address": "0x140002086", + "size": 3, + "mnemonic": "cmovne", + "operands": "edx, edi" + }, + { + "address": "0x140002089", + "size": 4, + "mnemonic": "or", + "operands": "edx, dword ptr [rcx + rbx + 0x10]" + }, + { + "address": "0x14000208d", + "size": 3, + "mnemonic": "or", + "operands": "edx, r8d" + }, + { + "address": "0x140002090", + "size": 3, + "mnemonic": "and", + "operands": "edx, 0x17" + }, + { + "address": "0x140002093", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rcx + rbx + 0x10], edx" + }, + { + "address": "0x140002097", + "size": 4, + "mnemonic": "and", + "operands": "edx, dword ptr [rcx + rbx + 0x14]" + }, + { + "address": "0x14000209b", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400020e1" + }, + { + "address": "0x14000209d", + "size": 5, + "mnemonic": "call", + "operands": "0x1400023f4" + }, + { + "address": "0x1400020a2", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x1400020a4", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400020b0" + }, + { + "address": "0x1400020a6", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x28]" + }, + { + "address": "0x1400020ab", + "size": 5, + "mnemonic": "call", + "operands": "0x140001d10" + }, + { + "address": "0x1400020b0", + "size": 5, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rsp + 0x28]" + }, + { + "address": "0x1400020b5", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdx]" + }, + { + "address": "0x1400020b8", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax + 4]" + }, + { + "address": "0x1400020bc", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + rdx + 0x48]" + }, + { + "address": "0x1400020c1", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x1400020c4", + "size": 2, + "mnemonic": "je", + "operands": "0x1400020cc" + } + ], + "successors": [ + "0x1400020cc", + "0x1400020c6" + ] + } + ] + }, + { + "address": "0x1400023f4", + "name": "", + "blocks": [ + { + "address": "0x1400023f4", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400023f4", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140006f50" + } + ], + "successors": [ + "0x140006f50" + ] + }, + { + "address": "0x140006f50", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006f50", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x140006f54", + "size": 5, + "mnemonic": "call", + "operands": "0x14000747c" + }, + { + "address": "0x140006f59", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x140006f5c", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140006f5e", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140006f61", + "size": 2, + "mnemonic": "je", + "operands": "0x140006f69" + } + ], + "successors": [ + "0x140006f69", + "0x140006f63" + ] + }, + { + "address": "0x140006f69", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140006f69", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x140006f6d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140006f63", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140006f63", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rcx + 0x30], eax" + }, + { + "address": "0x140006f66", + "size": 3, + "mnemonic": "setg", + "operands": "al" + }, + { + "address": "0x140006f69", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x140006f6d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140001d10", + "name": "", + "blocks": [ + { + "address": "0x140001d10", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001d10", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140001d12", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x140001d16", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140001d19", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x140001d1c", + "size": 4, + "mnemonic": "movsxd", + "operands": "rdx, dword ptr [rax + 4]" + }, + { + "address": "0x140001d20", + "size": 5, + "mnemonic": "cmp", + "operands": "dword ptr [rdx + rcx + 0x10], 0" + }, + { + "address": "0x140001d25", + "size": 2, + "mnemonic": "jne", + "operands": "0x140001d68" + }, + { + "address": "0x140001d27", + "size": 5, + "mnemonic": "test", + "operands": "byte ptr [rdx + rcx + 0x18], 2" + }, + { + "address": "0x140001d2c", + "size": 2, + "mnemonic": "je", + "operands": "0x140001d68" + } + ], + "successors": [ + "0x140001d68", + "0x140001d2e" + ] + }, + { + "address": "0x140001d68", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140001d68", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x140001d6c", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140001d6d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140001d2e", + "size": 20, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140001d2e", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdx + rcx + 0x48]" + }, + { + "address": "0x140001d33", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x140001d36", + "size": 3, + "mnemonic": "call", + "operands": "qword ptr [rax + 0x68]" + }, + { + "address": "0x140001d39", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, -1" + }, + { + "address": "0x140001d3c", + "size": 2, + "mnemonic": "jne", + "operands": "0x140001d68" + }, + { + "address": "0x140001d3e", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx]" + }, + { + "address": "0x140001d41", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax + 4]" + }, + { + "address": "0x140001d45", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 4" + }, + { + "address": "0x140001d4a", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140001d4c", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rcx + rbx + 0x48], rdx" + }, + { + "address": "0x140001d51", + "size": 3, + "mnemonic": "cmovne", + "operands": "eax, edx" + }, + { + "address": "0x140001d54", + "size": 4, + "mnemonic": "or", + "operands": "eax, dword ptr [rcx + rbx + 0x10]" + }, + { + "address": "0x140001d58", + "size": 3, + "mnemonic": "and", + "operands": "eax, 0x13" + }, + { + "address": "0x140001d5b", + "size": 3, + "mnemonic": "or", + "operands": "eax, 4" + }, + { + "address": "0x140001d5e", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rcx + rbx + 0x10], eax" + }, + { + "address": "0x140001d62", + "size": 4, + "mnemonic": "and", + "operands": "eax, dword ptr [rcx + rbx + 0x14]" + }, + { + "address": "0x140001d66", + "size": 2, + "mnemonic": "jne", + "operands": "0x140001d6e" + }, + { + "address": "0x140001d68", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x140001d6c", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140001d6d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140001df0", + "name": "", + "blocks": [ + { + "address": "0x140001df0", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001df0", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x140001df4", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x1e65d]" + }, + { + "address": "0x140001dfb", + "size": 5, + "mnemonic": "call", + "operands": "0x1400023ac" + }, + { + "address": "0x140001e00", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140001410", + "name": "", + "blocks": [ + { + "address": "0x140001410", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140001410", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x38" + }, + { + "address": "0x140001414", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140001417", + "size": 2, + "mnemonic": "jne", + "operands": "0x140001420" + }, + { + "address": "0x140001419", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000141b", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x38" + }, + { + "address": "0x14000141f", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001e3e0", + "name": "", + "blocks": [ + { + "address": "0x14001e3e0", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e3e0", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rcx" + }, + { + "address": "0x14001e3e3", + "size": 7, + "mnemonic": "lea", + "operands": "r10, [rip - 0x1e3ea]" + }, + { + "address": "0x14001e3ea", + "size": 4, + "mnemonic": "cmp", + "operands": "r8, 0xf" + }, + { + "address": "0x14001e3ee", + "size": 6, + "mnemonic": "ja", + "operands": "0x14001e500" + } + ], + "successors": [ + "0x14001e500", + "0x14001e3f4" + ] + }, + { + "address": "0x14001e500", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e500", + "size": 4, + "mnemonic": "cmp", + "operands": "r8, 0x20" + }, + { + "address": "0x14001e504", + "size": 2, + "mnemonic": "ja", + "operands": "0x14001e51d" + } + ], + "successors": [ + "0x14001e51d", + "0x14001e506" + ] + }, + { + "address": "0x14001e3f4", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e3f4", + "size": 12, + "mnemonic": "nop", + "operands": "word ptr [rax + rax]" + }, + { + "address": "0x14001e400", + "size": 8, + "mnemonic": "mov", + "operands": "r9d, dword ptr [r10 + r8*4 + 0x2ca10]" + }, + { + "address": "0x14001e408", + "size": 3, + "mnemonic": "add", + "operands": "r9, r10" + }, + { + "address": "0x14001e40b", + "size": 3, + "mnemonic": "jmp", + "operands": "r9" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001e51d", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e51d", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rdx + r8]" + }, + { + "address": "0x14001e521", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, rdx" + }, + { + "address": "0x14001e524", + "size": 4, + "mnemonic": "cmovbe", + "operands": "r9, rcx" + }, + { + "address": "0x14001e528", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, r9" + }, + { + "address": "0x14001e52b", + "size": 6, + "mnemonic": "jb", + "operands": "0x14001e970" + } + ], + "successors": [ + "0x14001e970", + "0x14001e531" + ] + }, + { + "address": "0x14001e506", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001e506", + "size": 4, + "mnemonic": "movdqu", + "operands": "xmm1, xmmword ptr [rdx]" + }, + { + "address": "0x14001e50a", + "size": 7, + "mnemonic": "movdqu", + "operands": "xmm2, xmmword ptr [rdx + r8 - 0x10]" + }, + { + "address": "0x14001e511", + "size": 4, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rcx], xmm1" + }, + { + "address": "0x14001e515", + "size": 7, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rcx + r8 - 0x10], xmm2" + }, + { + "address": "0x14001e51c", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001e970", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e970", + "size": 3, + "mnemonic": "movups", + "operands": "xmm2, xmmword ptr [rdx]" + }, + { + "address": "0x14001e973", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, rcx" + }, + { + "address": "0x14001e976", + "size": 3, + "mnemonic": "add", + "operands": "rcx, r8" + }, + { + "address": "0x14001e979", + "size": 5, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rcx + rdx - 0x10]" + }, + { + "address": "0x14001e97e", + "size": 4, + "mnemonic": "sub", + "operands": "rcx, 0x10" + }, + { + "address": "0x14001e982", + "size": 4, + "mnemonic": "sub", + "operands": "r8, 0x10" + }, + { + "address": "0x14001e986", + "size": 3, + "mnemonic": "test", + "operands": "cl, 0xf" + }, + { + "address": "0x14001e989", + "size": 2, + "mnemonic": "je", + "operands": "0x14001e9a3" + } + ], + "successors": [ + "0x14001e9a3", + "0x14001e98b" + ] + }, + { + "address": "0x14001e531", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e531", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x12b60], 3" + }, + { + "address": "0x14001e538", + "size": 6, + "mnemonic": "jb", + "operands": "0x14001e820" + } + ], + "successors": [ + "0x14001e820", + "0x14001e53e" + ] + }, + { + "address": "0x14001e9a3", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e9a3", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r8" + }, + { + "address": "0x14001e9a6", + "size": 4, + "mnemonic": "shr", + "operands": "r9, 7" + }, + { + "address": "0x14001e9aa", + "size": 2, + "mnemonic": "je", + "operands": "0x14001ea1d" + } + ], + "successors": [ + "0x14001ea1d", + "0x14001e9ac" + ] + }, + { + "address": "0x14001e98b", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e98b", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rcx" + }, + { + "address": "0x14001e98e", + "size": 4, + "mnemonic": "and", + "operands": "rcx, 0xfffffffffffffff0" + }, + { + "address": "0x14001e992", + "size": 3, + "mnemonic": "movups", + "operands": "xmm1, xmm0" + }, + { + "address": "0x14001e995", + "size": 4, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rcx + rdx]" + }, + { + "address": "0x14001e999", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [r9], xmm1" + }, + { + "address": "0x14001e99d", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rcx" + }, + { + "address": "0x14001e9a0", + "size": 3, + "mnemonic": "sub", + "operands": "r8, rax" + }, + { + "address": "0x14001e9a3", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r8" + }, + { + "address": "0x14001e9a6", + "size": 4, + "mnemonic": "shr", + "operands": "r9, 7" + }, + { + "address": "0x14001e9aa", + "size": 2, + "mnemonic": "je", + "operands": "0x14001ea1d" + } + ], + "successors": [ + "0x14001ea1d", + "0x14001e9ac" + ] + }, + { + "address": "0x14001e820", + "size": 45, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e820", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x800" + }, + { + "address": "0x14001e827", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14001e836" + }, + { + "address": "0x14001e829", + "size": 7, + "mnemonic": "test", + "operands": "byte ptr [rip + 0x13f0c], 2" + }, + { + "address": "0x14001e830", + "size": 6, + "mnemonic": "jne", + "operands": "0x14001e3d0" + }, + { + "address": "0x14001e836", + "size": 4, + "mnemonic": "movdqu", + "operands": "xmm0, xmmword ptr [rdx]" + }, + { + "address": "0x14001e83a", + "size": 7, + "mnemonic": "movdqu", + "operands": "xmm5, xmmword ptr [rdx + r8 - 0x10]" + }, + { + "address": "0x14001e841", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x80" + }, + { + "address": "0x14001e848", + "size": 6, + "mnemonic": "jbe", + "operands": "0x14001e8dc" + }, + { + "address": "0x14001e84e", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rcx" + }, + { + "address": "0x14001e851", + "size": 4, + "mnemonic": "and", + "operands": "r9, 0xf" + }, + { + "address": "0x14001e855", + "size": 4, + "mnemonic": "sub", + "operands": "r9, 0x10" + }, + { + "address": "0x14001e859", + "size": 3, + "mnemonic": "sub", + "operands": "rcx, r9" + }, + { + "address": "0x14001e85c", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x14001e85f", + "size": 3, + "mnemonic": "add", + "operands": "r8, r9" + }, + { + "address": "0x14001e862", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x80" + }, + { + "address": "0x14001e869", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14001e8dc" + }, + { + "address": "0x14001e86b", + "size": 5, + "mnemonic": "nop", + "operands": "dword ptr [rax + rax]" + }, + { + "address": "0x14001e870", + "size": 4, + "mnemonic": "movdqu", + "operands": "xmm1, xmmword ptr [rdx]" + }, + { + "address": "0x14001e874", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmm2, xmmword ptr [rdx + 0x10]" + }, + { + "address": "0x14001e879", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmm3, xmmword ptr [rdx + 0x20]" + }, + { + "address": "0x14001e87e", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmm4, xmmword ptr [rdx + 0x30]" + }, + { + "address": "0x14001e883", + "size": 4, + "mnemonic": "movdqa", + "operands": "xmmword ptr [rcx], xmm1" + }, + { + "address": "0x14001e887", + "size": 5, + "mnemonic": "movdqa", + "operands": "xmmword ptr [rcx + 0x10], xmm2" + }, + { + "address": "0x14001e88c", + "size": 5, + "mnemonic": "movdqa", + "operands": "xmmword ptr [rcx + 0x20], xmm3" + }, + { + "address": "0x14001e891", + "size": 5, + "mnemonic": "movdqa", + "operands": "xmmword ptr [rcx + 0x30], xmm4" + }, + { + "address": "0x14001e896", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmm1, xmmword ptr [rdx + 0x40]" + }, + { + "address": "0x14001e89b", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmm2, xmmword ptr [rdx + 0x50]" + }, + { + "address": "0x14001e8a0", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmm3, xmmword ptr [rdx + 0x60]" + }, + { + "address": "0x14001e8a5", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmm4, xmmword ptr [rdx + 0x70]" + }, + { + "address": "0x14001e8aa", + "size": 5, + "mnemonic": "movdqa", + "operands": "xmmword ptr [rcx + 0x40], xmm1" + }, + { + "address": "0x14001e8af", + "size": 5, + "mnemonic": "movdqa", + "operands": "xmmword ptr [rcx + 0x50], xmm2" + }, + { + "address": "0x14001e8b4", + "size": 5, + "mnemonic": "movdqa", + "operands": "xmmword ptr [rcx + 0x60], xmm3" + }, + { + "address": "0x14001e8b9", + "size": 5, + "mnemonic": "movdqa", + "operands": "xmmword ptr [rcx + 0x70], xmm4" + }, + { + "address": "0x14001e8be", + "size": 7, + "mnemonic": "add", + "operands": "rcx, 0x80" + }, + { + "address": "0x14001e8c5", + "size": 7, + "mnemonic": "add", + "operands": "rdx, 0x80" + }, + { + "address": "0x14001e8cc", + "size": 7, + "mnemonic": "sub", + "operands": "r8, 0x80" + }, + { + "address": "0x14001e8d3", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x80" + }, + { + "address": "0x14001e8da", + "size": 2, + "mnemonic": "jae", + "operands": "0x14001e870" + }, + { + "address": "0x14001e8dc", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [r8 + 0xf]" + }, + { + "address": "0x14001e8e0", + "size": 4, + "mnemonic": "and", + "operands": "r9, 0xfffffffffffffff0" + }, + { + "address": "0x14001e8e4", + "size": 3, + "mnemonic": "mov", + "operands": "r11, r9" + }, + { + "address": "0x14001e8e7", + "size": 4, + "mnemonic": "shr", + "operands": "r11, 4" + }, + { + "address": "0x14001e8eb", + "size": 8, + "mnemonic": "mov", + "operands": "r11d, dword ptr [r10 + r11*4 + 0x2ca98]" + }, + { + "address": "0x14001e8f3", + "size": 3, + "mnemonic": "add", + "operands": "r11, r10" + }, + { + "address": "0x14001e8f6", + "size": 3, + "mnemonic": "jmp", + "operands": "r11" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001e53e", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e53e", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x2000" + }, + { + "address": "0x14001e545", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14001e55d" + }, + { + "address": "0x14001e547", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x180000" + }, + { + "address": "0x14001e54e", + "size": 2, + "mnemonic": "ja", + "operands": "0x14001e55d" + } + ], + "successors": [ + "0x14001e55d", + "0x14001e550" + ] + }, + { + "address": "0x14001ea1d", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ea1d", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r8" + }, + { + "address": "0x14001ea20", + "size": 4, + "mnemonic": "shr", + "operands": "r9, 4" + }, + { + "address": "0x14001ea24", + "size": 2, + "mnemonic": "je", + "operands": "0x14001ea40" + } + ], + "successors": [ + "0x14001ea40", + "0x14001ea26" + ] + }, + { + "address": "0x14001e9ac", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e9ac", + "size": 3, + "mnemonic": "movaps", + "operands": "xmmword ptr [rcx], xmm0" + }, + { + "address": "0x14001e9af", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001e9c7" + } + ], + "successors": [ + "0x14001e9c7" + ] + }, + { + "address": "0x14001e55d", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e55d", + "size": 4, + "mnemonic": "vmovdqu", + "operands": "ymm0, ymmword ptr [rdx]" + }, + { + "address": "0x14001e561", + "size": 7, + "mnemonic": "vmovdqu", + "operands": "ymm5, ymmword ptr [rdx + r8 - 0x20]" + }, + { + "address": "0x14001e568", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x100" + }, + { + "address": "0x14001e56f", + "size": 6, + "mnemonic": "jbe", + "operands": "0x14001e638" + }, + { + "address": "0x14001e575", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rcx" + }, + { + "address": "0x14001e578", + "size": 4, + "mnemonic": "and", + "operands": "r9, 0x1f" + }, + { + "address": "0x14001e57c", + "size": 4, + "mnemonic": "sub", + "operands": "r9, 0x20" + }, + { + "address": "0x14001e580", + "size": 3, + "mnemonic": "sub", + "operands": "rcx, r9" + }, + { + "address": "0x14001e583", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x14001e586", + "size": 3, + "mnemonic": "add", + "operands": "r8, r9" + }, + { + "address": "0x14001e589", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x100" + }, + { + "address": "0x14001e590", + "size": 6, + "mnemonic": "jbe", + "operands": "0x14001e638" + }, + { + "address": "0x14001e596", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x180000" + }, + { + "address": "0x14001e59d", + "size": 6, + "mnemonic": "ja", + "operands": "0x14001e6e0" + } + ], + "successors": [ + "0x14001e6e0", + "0x14001e5a3" + ] + }, + { + "address": "0x14001e550", + "size": 16, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e550", + "size": 7, + "mnemonic": "test", + "operands": "byte ptr [rip + 0x141e5], 2" + }, + { + "address": "0x14001e557", + "size": 6, + "mnemonic": "jne", + "operands": "0x14001e3d0" + }, + { + "address": "0x14001e55d", + "size": 4, + "mnemonic": "vmovdqu", + "operands": "ymm0, ymmword ptr [rdx]" + }, + { + "address": "0x14001e561", + "size": 7, + "mnemonic": "vmovdqu", + "operands": "ymm5, ymmword ptr [rdx + r8 - 0x20]" + }, + { + "address": "0x14001e568", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x100" + }, + { + "address": "0x14001e56f", + "size": 6, + "mnemonic": "jbe", + "operands": "0x14001e638" + }, + { + "address": "0x14001e575", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rcx" + }, + { + "address": "0x14001e578", + "size": 4, + "mnemonic": "and", + "operands": "r9, 0x1f" + }, + { + "address": "0x14001e57c", + "size": 4, + "mnemonic": "sub", + "operands": "r9, 0x20" + }, + { + "address": "0x14001e580", + "size": 3, + "mnemonic": "sub", + "operands": "rcx, r9" + }, + { + "address": "0x14001e583", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x14001e586", + "size": 3, + "mnemonic": "add", + "operands": "r8, r9" + }, + { + "address": "0x14001e589", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x100" + }, + { + "address": "0x14001e590", + "size": 6, + "mnemonic": "jbe", + "operands": "0x14001e638" + }, + { + "address": "0x14001e596", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x180000" + }, + { + "address": "0x14001e59d", + "size": 6, + "mnemonic": "ja", + "operands": "0x14001e6e0" + } + ], + "successors": [ + "0x14001e6e0", + "0x14001e5a3" + ] + }, + { + "address": "0x14001ea40", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ea40", + "size": 4, + "mnemonic": "and", + "operands": "r8, 0xf" + }, + { + "address": "0x14001ea44", + "size": 2, + "mnemonic": "je", + "operands": "0x14001ea49" + } + ], + "successors": [ + "0x14001ea49", + "0x14001ea46" + ] + }, + { + "address": "0x14001ea26", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ea26", + "size": 10, + "mnemonic": "nop", + "operands": "word ptr [rax + rax]" + }, + { + "address": "0x14001ea30", + "size": 3, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx], xmm0" + }, + { + "address": "0x14001ea33", + "size": 4, + "mnemonic": "sub", + "operands": "rcx, 0x10" + }, + { + "address": "0x14001ea37", + "size": 4, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rcx + rdx]" + }, + { + "address": "0x14001ea3b", + "size": 3, + "mnemonic": "dec", + "operands": "r9" + }, + { + "address": "0x14001ea3e", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001ea30" + }, + { + "address": "0x14001ea40", + "size": 4, + "mnemonic": "and", + "operands": "r8, 0xf" + }, + { + "address": "0x14001ea44", + "size": 2, + "mnemonic": "je", + "operands": "0x14001ea49" + } + ], + "successors": [ + "0x14001ea49", + "0x14001ea46" + ] + }, + { + "address": "0x14001e9c7", + "size": 23, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e9c7", + "size": 5, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rcx + rdx - 0x10]" + }, + { + "address": "0x14001e9cc", + "size": 5, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rcx + rdx - 0x20]" + }, + { + "address": "0x14001e9d1", + "size": 7, + "mnemonic": "sub", + "operands": "rcx, 0x80" + }, + { + "address": "0x14001e9d8", + "size": 4, + "mnemonic": "movaps", + "operands": "xmmword ptr [rcx + 0x70], xmm0" + }, + { + "address": "0x14001e9dc", + "size": 4, + "mnemonic": "movaps", + "operands": "xmmword ptr [rcx + 0x60], xmm1" + }, + { + "address": "0x14001e9e0", + "size": 5, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rcx + rdx + 0x50]" + }, + { + "address": "0x14001e9e5", + "size": 5, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rcx + rdx + 0x40]" + }, + { + "address": "0x14001e9ea", + "size": 3, + "mnemonic": "dec", + "operands": "r9" + }, + { + "address": "0x14001e9ed", + "size": 4, + "mnemonic": "movaps", + "operands": "xmmword ptr [rcx + 0x50], xmm0" + }, + { + "address": "0x14001e9f1", + "size": 4, + "mnemonic": "movaps", + "operands": "xmmword ptr [rcx + 0x40], xmm1" + }, + { + "address": "0x14001e9f5", + "size": 5, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rcx + rdx + 0x30]" + }, + { + "address": "0x14001e9fa", + "size": 5, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rcx + rdx + 0x20]" + }, + { + "address": "0x14001e9ff", + "size": 4, + "mnemonic": "movaps", + "operands": "xmmword ptr [rcx + 0x30], xmm0" + }, + { + "address": "0x14001ea03", + "size": 4, + "mnemonic": "movaps", + "operands": "xmmword ptr [rcx + 0x20], xmm1" + }, + { + "address": "0x14001ea07", + "size": 5, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rcx + rdx + 0x10]" + }, + { + "address": "0x14001ea0c", + "size": 4, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rcx + rdx]" + }, + { + "address": "0x14001ea10", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001e9c0" + }, + { + "address": "0x14001ea12", + "size": 4, + "mnemonic": "movaps", + "operands": "xmmword ptr [rcx + 0x10], xmm0" + }, + { + "address": "0x14001ea16", + "size": 4, + "mnemonic": "and", + "operands": "r8, 0x7f" + }, + { + "address": "0x14001ea1a", + "size": 3, + "mnemonic": "movaps", + "operands": "xmm0, xmm1" + }, + { + "address": "0x14001ea1d", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r8" + }, + { + "address": "0x14001ea20", + "size": 4, + "mnemonic": "shr", + "operands": "r9, 4" + }, + { + "address": "0x14001ea24", + "size": 2, + "mnemonic": "je", + "operands": "0x14001ea40" + } + ], + "successors": [ + "0x14001ea40", + "0x14001ea26" + ] + }, + { + "address": "0x14001e6e0", + "size": 28, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e6e0", + "size": 4, + "mnemonic": "vmovdqu", + "operands": "ymm1, ymmword ptr [rdx]" + }, + { + "address": "0x14001e6e4", + "size": 5, + "mnemonic": "vmovdqu", + "operands": "ymm2, ymmword ptr [rdx + 0x20]" + }, + { + "address": "0x14001e6e9", + "size": 5, + "mnemonic": "vmovdqu", + "operands": "ymm3, ymmword ptr [rdx + 0x40]" + }, + { + "address": "0x14001e6ee", + "size": 5, + "mnemonic": "vmovdqu", + "operands": "ymm4, ymmword ptr [rdx + 0x60]" + }, + { + "address": "0x14001e6f3", + "size": 4, + "mnemonic": "vmovntdq", + "operands": "ymmword ptr [rcx], ymm1" + }, + { + "address": "0x14001e6f7", + "size": 5, + "mnemonic": "vmovntdq", + "operands": "ymmword ptr [rcx + 0x20], ymm2" + }, + { + "address": "0x14001e6fc", + "size": 5, + "mnemonic": "vmovntdq", + "operands": "ymmword ptr [rcx + 0x40], ymm3" + }, + { + "address": "0x14001e701", + "size": 5, + "mnemonic": "vmovntdq", + "operands": "ymmword ptr [rcx + 0x60], ymm4" + }, + { + "address": "0x14001e706", + "size": 8, + "mnemonic": "vmovdqu", + "operands": "ymm1, ymmword ptr [rdx + 0x80]" + }, + { + "address": "0x14001e70e", + "size": 8, + "mnemonic": "vmovdqu", + "operands": "ymm2, ymmword ptr [rdx + 0xa0]" + }, + { + "address": "0x14001e716", + "size": 8, + "mnemonic": "vmovdqu", + "operands": "ymm3, ymmword ptr [rdx + 0xc0]" + }, + { + "address": "0x14001e71e", + "size": 8, + "mnemonic": "vmovdqu", + "operands": "ymm4, ymmword ptr [rdx + 0xe0]" + }, + { + "address": "0x14001e726", + "size": 8, + "mnemonic": "vmovntdq", + "operands": "ymmword ptr [rcx + 0x80], ymm1" + }, + { + "address": "0x14001e72e", + "size": 8, + "mnemonic": "vmovntdq", + "operands": "ymmword ptr [rcx + 0xa0], ymm2" + }, + { + "address": "0x14001e736", + "size": 8, + "mnemonic": "vmovntdq", + "operands": "ymmword ptr [rcx + 0xc0], ymm3" + }, + { + "address": "0x14001e73e", + "size": 8, + "mnemonic": "vmovntdq", + "operands": "ymmword ptr [rcx + 0xe0], ymm4" + }, + { + "address": "0x14001e746", + "size": 7, + "mnemonic": "add", + "operands": "rcx, 0x100" + }, + { + "address": "0x14001e74d", + "size": 7, + "mnemonic": "add", + "operands": "rdx, 0x100" + }, + { + "address": "0x14001e754", + "size": 7, + "mnemonic": "sub", + "operands": "r8, 0x100" + }, + { + "address": "0x14001e75b", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x100" + }, + { + "address": "0x14001e762", + "size": 6, + "mnemonic": "jae", + "operands": "0x14001e6e0" + }, + { + "address": "0x14001e768", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [r8 + 0x1f]" + }, + { + "address": "0x14001e76c", + "size": 4, + "mnemonic": "and", + "operands": "r9, 0xffffffffffffffe0" + }, + { + "address": "0x14001e770", + "size": 3, + "mnemonic": "mov", + "operands": "r11, r9" + }, + { + "address": "0x14001e773", + "size": 4, + "mnemonic": "shr", + "operands": "r11, 5" + }, + { + "address": "0x14001e777", + "size": 8, + "mnemonic": "mov", + "operands": "r11d, dword ptr [r10 + r11*4 + 0x2ca74]" + }, + { + "address": "0x14001e77f", + "size": 3, + "mnemonic": "add", + "operands": "r11, r10" + }, + { + "address": "0x14001e782", + "size": 3, + "mnemonic": "jmp", + "operands": "r11" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001e5a3", + "size": 29, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e5a3", + "size": 13, + "mnemonic": "nop", + "operands": "word ptr [rax + rax]" + }, + { + "address": "0x14001e5b0", + "size": 4, + "mnemonic": "vmovdqu", + "operands": "ymm1, ymmword ptr [rdx]" + }, + { + "address": "0x14001e5b4", + "size": 5, + "mnemonic": "vmovdqu", + "operands": "ymm2, ymmword ptr [rdx + 0x20]" + }, + { + "address": "0x14001e5b9", + "size": 5, + "mnemonic": "vmovdqu", + "operands": "ymm3, ymmword ptr [rdx + 0x40]" + }, + { + "address": "0x14001e5be", + "size": 5, + "mnemonic": "vmovdqu", + "operands": "ymm4, ymmword ptr [rdx + 0x60]" + }, + { + "address": "0x14001e5c3", + "size": 4, + "mnemonic": "vmovdqa", + "operands": "ymmword ptr [rcx], ymm1" + }, + { + "address": "0x14001e5c7", + "size": 5, + "mnemonic": "vmovdqa", + "operands": "ymmword ptr [rcx + 0x20], ymm2" + }, + { + "address": "0x14001e5cc", + "size": 5, + "mnemonic": "vmovdqa", + "operands": "ymmword ptr [rcx + 0x40], ymm3" + }, + { + "address": "0x14001e5d1", + "size": 5, + "mnemonic": "vmovdqa", + "operands": "ymmword ptr [rcx + 0x60], ymm4" + }, + { + "address": "0x14001e5d6", + "size": 8, + "mnemonic": "vmovdqu", + "operands": "ymm1, ymmword ptr [rdx + 0x80]" + }, + { + "address": "0x14001e5de", + "size": 8, + "mnemonic": "vmovdqu", + "operands": "ymm2, ymmword ptr [rdx + 0xa0]" + }, + { + "address": "0x14001e5e6", + "size": 8, + "mnemonic": "vmovdqu", + "operands": "ymm3, ymmword ptr [rdx + 0xc0]" + }, + { + "address": "0x14001e5ee", + "size": 8, + "mnemonic": "vmovdqu", + "operands": "ymm4, ymmword ptr [rdx + 0xe0]" + }, + { + "address": "0x14001e5f6", + "size": 8, + "mnemonic": "vmovdqa", + "operands": "ymmword ptr [rcx + 0x80], ymm1" + }, + { + "address": "0x14001e5fe", + "size": 8, + "mnemonic": "vmovdqa", + "operands": "ymmword ptr [rcx + 0xa0], ymm2" + }, + { + "address": "0x14001e606", + "size": 8, + "mnemonic": "vmovdqa", + "operands": "ymmword ptr [rcx + 0xc0], ymm3" + }, + { + "address": "0x14001e60e", + "size": 8, + "mnemonic": "vmovdqa", + "operands": "ymmword ptr [rcx + 0xe0], ymm4" + }, + { + "address": "0x14001e616", + "size": 7, + "mnemonic": "add", + "operands": "rcx, 0x100" + }, + { + "address": "0x14001e61d", + "size": 7, + "mnemonic": "add", + "operands": "rdx, 0x100" + }, + { + "address": "0x14001e624", + "size": 7, + "mnemonic": "sub", + "operands": "r8, 0x100" + }, + { + "address": "0x14001e62b", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x100" + }, + { + "address": "0x14001e632", + "size": 6, + "mnemonic": "jae", + "operands": "0x14001e5b0" + }, + { + "address": "0x14001e638", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [r8 + 0x1f]" + }, + { + "address": "0x14001e63c", + "size": 4, + "mnemonic": "and", + "operands": "r9, 0xffffffffffffffe0" + }, + { + "address": "0x14001e640", + "size": 3, + "mnemonic": "mov", + "operands": "r11, r9" + }, + { + "address": "0x14001e643", + "size": 4, + "mnemonic": "shr", + "operands": "r11, 5" + }, + { + "address": "0x14001e647", + "size": 8, + "mnemonic": "mov", + "operands": "r11d, dword ptr [r10 + r11*4 + 0x2ca50]" + }, + { + "address": "0x14001e64f", + "size": 3, + "mnemonic": "add", + "operands": "r11, r10" + }, + { + "address": "0x14001e652", + "size": 3, + "mnemonic": "jmp", + "operands": "r11" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001ea49", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001ea49", + "size": 3, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx], xmm0" + }, + { + "address": "0x14001ea4c", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001ea46", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001ea46", + "size": 3, + "mnemonic": "movups", + "operands": "xmmword ptr [rax], xmm2" + }, + { + "address": "0x14001ea49", + "size": 3, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx], xmm0" + }, + { + "address": "0x14001ea4c", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140001e10", + "name": "", + "blocks": [ + { + "address": "0x140001e10", + "size": 16, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001e10", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rbx" + }, + { + "address": "0x140001e15", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140001e16", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140001e17", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140001e19", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140001e1b", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140001e1d", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x140001e21", + "size": 4, + "mnemonic": "mov", + "operands": "r15, qword ptr [rcx + 0x18]" + }, + { + "address": "0x140001e25", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, r8" + }, + { + "address": "0x140001e28", + "size": 4, + "mnemonic": "mov", + "operands": "r14, qword ptr [rcx + 0x10]" + }, + { + "address": "0x140001e2c", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r15" + }, + { + "address": "0x140001e2f", + "size": 3, + "mnemonic": "sub", + "operands": "rax, r14" + }, + { + "address": "0x140001e32", + "size": 3, + "mnemonic": "mov", + "operands": "r13, rdx" + }, + { + "address": "0x140001e35", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x140001e38", + "size": 3, + "mnemonic": "cmp", + "operands": "r8, rax" + }, + { + "address": "0x140001e3b", + "size": 2, + "mnemonic": "ja", + "operands": "0x140001e66" + } + ], + "successors": [ + "0x140001e66", + "0x140001e3d" + ] + }, + { + "address": "0x140001e66", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001e66", + "size": 10, + "mnemonic": "movabs", + "operands": "rbx, 0x7fffffffffffffff" + }, + { + "address": "0x140001e70", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140001e73", + "size": 3, + "mnemonic": "sub", + "operands": "rax, r14" + }, + { + "address": "0x140001e76", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, rsi" + }, + { + "address": "0x140001e79", + "size": 6, + "mnemonic": "jb", + "operands": "0x140001f66" + } + ], + "successors": [ + "0x140001f66", + "0x140001e7f" + ] + }, + { + "address": "0x140001e3d", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001e3d", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r14 + r8]" + }, + { + "address": "0x140001e41", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 0x10], rax" + }, + { + "address": "0x140001e45", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rcx" + }, + { + "address": "0x140001e48", + "size": 4, + "mnemonic": "cmp", + "operands": "r15, 0xf" + }, + { + "address": "0x140001e4c", + "size": 2, + "mnemonic": "jbe", + "operands": "0x140001e51" + }, + { + "address": "0x140001e4e", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x140001e51", + "size": 4, + "mnemonic": "lea", + "operands": "rbx, [r14 + rax]" + }, + { + "address": "0x140001e55", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140001e58", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3e0" + }, + { + "address": "0x140001e5d", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbx + rsi], 0" + }, + { + "address": "0x140001e61", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140001f51" + } + ], + "successors": [ + "0x140001f51" + ] + }, + { + "address": "0x140001f66", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001f66", + "size": 5, + "mnemonic": "call", + "operands": "0x140001df0" + }, + { + "address": "0x140001f6b", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140001e7f", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001e7f", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x60], rbp" + }, + { + "address": "0x140001e84", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x68], r12" + }, + { + "address": "0x140001e89", + "size": 4, + "mnemonic": "lea", + "operands": "r12, [r14 + r8]" + }, + { + "address": "0x140001e8d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r12" + }, + { + "address": "0x140001e90", + "size": 4, + "mnemonic": "or", + "operands": "rcx, 0xf" + }, + { + "address": "0x140001e94", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, rbx" + }, + { + "address": "0x140001e97", + "size": 2, + "mnemonic": "ja", + "operands": "0x140001eb8" + } + ], + "successors": [ + "0x140001eb8", + "0x140001e99" + ] + }, + { + "address": "0x140001f51", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140001f51", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140001f56", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdi" + }, + { + "address": "0x140001f59", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140001f5d", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140001f5f", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140001f61", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140001f63", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140001f64", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140001f65", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140001eb8", + "size": 21, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001eb8", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbx + 1]" + }, + { + "address": "0x140001ebc", + "size": 5, + "mnemonic": "call", + "operands": "0x140001410" + }, + { + "address": "0x140001ec1", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rdi + 0x10], r12" + }, + { + "address": "0x140001ec5", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rax" + }, + { + "address": "0x140001ec8", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rdi + 0x18], rbx" + }, + { + "address": "0x140001ecc", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x140001ecf", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x140001ed2", + "size": 4, + "mnemonic": "lea", + "operands": "r12, [r14 + rax]" + }, + { + "address": "0x140001ed6", + "size": 4, + "mnemonic": "cmp", + "operands": "r15, 0xf" + }, + { + "address": "0x140001eda", + "size": 2, + "mnemonic": "jbe", + "operands": "0x140001f29" + }, + { + "address": "0x140001edc", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rdi]" + }, + { + "address": "0x140001edf", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x140001ee2", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3e0" + }, + { + "address": "0x140001ee7", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rsi" + }, + { + "address": "0x140001eea", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r13" + }, + { + "address": "0x140001eed", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r12" + }, + { + "address": "0x140001ef0", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3e0" + }, + { + "address": "0x140001ef5", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [r15 + 1]" + }, + { + "address": "0x140001ef9", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [r12 + rsi], 0" + }, + { + "address": "0x140001efe", + "size": 7, + "mnemonic": "cmp", + "operands": "rdx, 0x1000" + }, + { + "address": "0x140001f05", + "size": 2, + "mnemonic": "jb", + "operands": "0x140001f1f" + } + ], + "successors": [ + "0x140001f1f", + "0x140001f07" + ] + }, + { + "address": "0x140001e99", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001e99", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r15" + }, + { + "address": "0x140001e9c", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140001e9f", + "size": 3, + "mnemonic": "shr", + "operands": "rdx, 1" + }, + { + "address": "0x140001ea2", + "size": 3, + "mnemonic": "sub", + "operands": "rax, rdx" + }, + { + "address": "0x140001ea5", + "size": 3, + "mnemonic": "cmp", + "operands": "r15, rax" + }, + { + "address": "0x140001ea8", + "size": 2, + "mnemonic": "ja", + "operands": "0x140001eb8" + } + ], + "successors": [ + "0x140001eb8", + "0x140001eaa" + ] + }, + { + "address": "0x140001f1f", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001f1f", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140001f22", + "size": 5, + "mnemonic": "call", + "operands": "0x140005170" + }, + { + "address": "0x140001f27", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140001f44" + } + ], + "successors": [ + "0x140001f44" + ] + }, + { + "address": "0x140001f07", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001f07", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx - 8]" + }, + { + "address": "0x140001f0b", + "size": 4, + "mnemonic": "add", + "operands": "rdx, 0x27" + }, + { + "address": "0x140001f0f", + "size": 3, + "mnemonic": "sub", + "operands": "rbx, rax" + }, + { + "address": "0x140001f12", + "size": 4, + "mnemonic": "sub", + "operands": "rbx, 8" + }, + { + "address": "0x140001f16", + "size": 4, + "mnemonic": "cmp", + "operands": "rbx, 0x1f" + }, + { + "address": "0x140001f1a", + "size": 2, + "mnemonic": "ja", + "operands": "0x140001f6c" + } + ], + "successors": [ + "0x140001f6c", + "0x140001f1c" + ] + }, + { + "address": "0x140001eaa", + "size": 25, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001eaa", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r15 + rdx]" + }, + { + "address": "0x140001eae", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140001eb1", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, rax" + }, + { + "address": "0x140001eb4", + "size": 4, + "mnemonic": "cmovb", + "operands": "rbx, rax" + }, + { + "address": "0x140001eb8", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbx + 1]" + }, + { + "address": "0x140001ebc", + "size": 5, + "mnemonic": "call", + "operands": "0x140001410" + }, + { + "address": "0x140001ec1", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rdi + 0x10], r12" + }, + { + "address": "0x140001ec5", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rax" + }, + { + "address": "0x140001ec8", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rdi + 0x18], rbx" + }, + { + "address": "0x140001ecc", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x140001ecf", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x140001ed2", + "size": 4, + "mnemonic": "lea", + "operands": "r12, [r14 + rax]" + }, + { + "address": "0x140001ed6", + "size": 4, + "mnemonic": "cmp", + "operands": "r15, 0xf" + }, + { + "address": "0x140001eda", + "size": 2, + "mnemonic": "jbe", + "operands": "0x140001f29" + }, + { + "address": "0x140001edc", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rdi]" + }, + { + "address": "0x140001edf", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x140001ee2", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3e0" + }, + { + "address": "0x140001ee7", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rsi" + }, + { + "address": "0x140001eea", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r13" + }, + { + "address": "0x140001eed", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r12" + }, + { + "address": "0x140001ef0", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3e0" + }, + { + "address": "0x140001ef5", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [r15 + 1]" + }, + { + "address": "0x140001ef9", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [r12 + rsi], 0" + }, + { + "address": "0x140001efe", + "size": 7, + "mnemonic": "cmp", + "operands": "rdx, 0x1000" + }, + { + "address": "0x140001f05", + "size": 2, + "mnemonic": "jb", + "operands": "0x140001f1f" + } + ], + "successors": [ + "0x140001f1f", + "0x140001f07" + ] + }, + { + "address": "0x140001f44", + "size": 12, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140001f44", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rdi], rbp" + }, + { + "address": "0x140001f47", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x60]" + }, + { + "address": "0x140001f4c", + "size": 5, + "mnemonic": "mov", + "operands": "r12, qword ptr [rsp + 0x68]" + }, + { + "address": "0x140001f51", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140001f56", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdi" + }, + { + "address": "0x140001f59", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140001f5d", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140001f5f", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140001f61", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140001f63", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140001f64", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140001f65", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140001f6c", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001f6c", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x140001f6f", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], 0" + }, + { + "address": "0x140001f78", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x140001f7b", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140001f7d", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x140001f7f", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afd4" + }, + { + "address": "0x140001f84", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140001f1c", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001f1c", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x140001f1f", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140001f22", + "size": 5, + "mnemonic": "call", + "operands": "0x140005170" + }, + { + "address": "0x140001f27", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140001f44" + } + ], + "successors": [ + "0x140001f44" + ] + } + ] + }, + { + "address": "0x140005170", + "name": "", + "blocks": [ + { + "address": "0x140005170", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005170", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140005a88" + } + ], + "successors": [ + "0x140005a88" + ] + }, + { + "address": "0x140005a88", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005a88", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000c9d0" + } + ], + "successors": [ + "0x14000c9d0" + ] + }, + { + "address": "0x14000c9d0", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000c9d0", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140011b00" + } + ], + "successors": [ + "0x140011b00" + ] + }, + { + "address": "0x140011b00", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011b00", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140011b03", + "size": 2, + "mnemonic": "je", + "operands": "0x140011b3b" + } + ], + "successors": [ + "0x140011b3b", + "0x140011b05" + ] + }, + { + "address": "0x140011b3b", + "size": 1, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140011b3b", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140011b05", + "size": 17, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140011b05", + "size": 1, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140011b06", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140011b0a", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rcx" + }, + { + "address": "0x140011b0d", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140011b0f", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rip + 0x21d42]" + }, + { + "address": "0x140011b16", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xe66c]" + }, + { + "address": "0x140011b1c", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140011b1e", + "size": 2, + "mnemonic": "jne", + "operands": "0x140011b36" + }, + { + "address": "0x140011b20", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xe5d2]" + }, + { + "address": "0x140011b26", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, eax" + }, + { + "address": "0x140011b28", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d738" + }, + { + "address": "0x140011b2d", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, eax" + }, + { + "address": "0x140011b2f", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x140011b34", + "size": 2, + "mnemonic": "mov", + "operands": "dword ptr [rax], ebx" + }, + { + "address": "0x140011b36", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140011b3a", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140011b3b", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400060f0", + "name": "", + "blocks": [ + { + "address": "0x1400060f0", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400060f0", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x1400060f5", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x1400060fa", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x1400060ff", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140006100", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140006104", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rcx + 8], 0" + }, + { + "address": "0x140006108", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x14000610b", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14000610e", + "size": 2, + "mnemonic": "je", + "operands": "0x14000614f" + } + ], + "successors": [ + "0x14000614f", + "0x140006110" + ] + }, + { + "address": "0x14000614f", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000614f", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx]" + }, + { + "address": "0x140006152", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rdx], rax" + }, + { + "address": "0x140006155", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rdx + 8], 0" + }, + { + "address": "0x140006159", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000615e", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x38]" + }, + { + "address": "0x140006163", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140006168", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000616c", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000616d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140006110", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006110", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx]" + }, + { + "address": "0x140006113", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140006116", + "size": 2, + "mnemonic": "je", + "operands": "0x14000614f" + } + ], + "successors": [ + "0x14000614f", + "0x140006118" + ] + }, + { + "address": "0x140006118", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006118", + "size": 5, + "mnemonic": "call", + "operands": "0x14001ef10" + }, + { + "address": "0x14000611d", + "size": 4, + "mnemonic": "lea", + "operands": "rbp, [rax + 1]" + }, + { + "address": "0x140006121", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbp" + }, + { + "address": "0x140006124", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cac0" + }, + { + "address": "0x140006129", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rax" + }, + { + "address": "0x14000612c", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x14000612f", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140006132", + "size": 2, + "mnemonic": "je", + "operands": "0x140006148" + } + ], + "successors": [ + "0x140006148", + "0x140006134" + ] + }, + { + "address": "0x140006148", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006148", + "size": 5, + "mnemonic": "call", + "operands": "0x14000c9d0" + }, + { + "address": "0x14000614d", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140006159" + } + ], + "successors": [ + "0x140006159" + ] + }, + { + "address": "0x140006134", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006134", + "size": 3, + "mnemonic": "mov", + "operands": "r8, qword ptr [rbx]" + }, + { + "address": "0x140006137", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbp" + }, + { + "address": "0x14000613a", + "size": 5, + "mnemonic": "call", + "operands": "0x140010b90" + }, + { + "address": "0x14000613f", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x140006141", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rdi], rsi" + }, + { + "address": "0x140006144", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rdi + 8], 1" + }, + { + "address": "0x140006148", + "size": 5, + "mnemonic": "call", + "operands": "0x14000c9d0" + }, + { + "address": "0x14000614d", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140006159" + } + ], + "successors": [ + "0x140006159" + ] + }, + { + "address": "0x140006159", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140006159", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000615e", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x38]" + }, + { + "address": "0x140006163", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140006168", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000616c", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000616d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140005210", + "name": "", + "blocks": [ + { + "address": "0x140005210", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140005210", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x2be29]" + }, + { + "address": "0x140005217", + "size": 2, + "mnemonic": "jne", + "operands": "0x140005229" + }, + { + "address": "0x140005219", + "size": 4, + "mnemonic": "rol", + "operands": "rcx, 0x10" + }, + { + "address": "0x14000521d", + "size": 5, + "mnemonic": "test", + "operands": "cx, 0xffff" + }, + { + "address": "0x140005222", + "size": 2, + "mnemonic": "jne", + "operands": "0x140005225" + }, + { + "address": "0x140005224", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000afd4", + "name": "", + "blocks": [ + { + "address": "0x14000afd4", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000afd4", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000afd8", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0x17" + }, + { + "address": "0x14000afdd", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x150ad]" + }, + { + "address": "0x14000afe3", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000afe5", + "size": 2, + "mnemonic": "je", + "operands": "0x14000afee" + } + ], + "successors": [ + "0x14000afee", + "0x14000afe7" + ] + }, + { + "address": "0x14000afee", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000afee", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 1" + }, + { + "address": "0x14000aff4", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0xc0000417" + }, + { + "address": "0x14000aff9", + "size": 4, + "mnemonic": "lea", + "operands": "ecx, [r8 + 1]" + }, + { + "address": "0x14000affd", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ace8" + }, + { + "address": "0x14000b002", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x15078]" + }, + { + "address": "0x14000b008", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x14000b00b", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0xc0000417" + }, + { + "address": "0x14000b010", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000b014", + "size": 7, + "mnemonic": "jmp", + "operands": "qword ptr [rip + 0x1506d]" + } + ], + "successors": [ + "0x140020088" + ] + }, + { + "address": "0x14000afe7", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000afe7", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 5" + }, + { + "address": "0x14000afec", + "size": 2, + "mnemonic": "int", + "operands": "0x29" + }, + { + "address": "0x14000afee", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 1" + }, + { + "address": "0x14000aff4", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0xc0000417" + }, + { + "address": "0x14000aff9", + "size": 4, + "mnemonic": "lea", + "operands": "ecx, [r8 + 1]" + }, + { + "address": "0x14000affd", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ace8" + }, + { + "address": "0x14000b002", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x15078]" + }, + { + "address": "0x14000b008", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x14000b00b", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0xc0000417" + }, + { + "address": "0x14000b010", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000b014", + "size": 7, + "mnemonic": "jmp", + "operands": "qword ptr [rip + 0x1506d]" + } + ], + "successors": [ + "0x140020088" + ] + }, + { + "address": "0x140020088", + "size": 0, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000448c", + "name": "", + "blocks": [ + { + "address": "0x14000448c", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000448c", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x14000448e", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140004492", + "size": 2, + "mnemonic": "mov", + "operands": "dword ptr [rcx], edx" + }, + { + "address": "0x140004494", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140004497", + "size": 2, + "mnemonic": "test", + "operands": "edx, edx" + }, + { + "address": "0x140004499", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400044a2" + }, + { + "address": "0x14000449b", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca90" + }, + { + "address": "0x1400044a0", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400044be" + } + ], + "successors": [ + "0x1400044be" + ] + }, + { + "address": "0x1400044be", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400044be", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x1400044c1", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400044c5", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x1400044c6", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140004504", + "name": "", + "blocks": [ + { + "address": "0x140004504", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004504", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x140004508", + "size": 3, + "mnemonic": "movsxd", + "operands": "rax, dword ptr [rcx]" + }, + { + "address": "0x14000450b", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000450d", + "size": 2, + "mnemonic": "jne", + "operands": "0x140004518" + }, + { + "address": "0x14000450f", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x140004513", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000caac" + } + ], + "successors": [ + "0x14000caac" + ] + }, + { + "address": "0x14000caac", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000caac", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x263ed]" + }, + { + "address": "0x14000cab3", + "size": 7, + "mnemonic": "jmp", + "operands": "qword ptr [rip + 0x1355e]" + } + ], + "successors": [ + "0x140020018" + ] + } + ] + }, + { + "address": "0x140004650", + "name": "", + "blocks": [ + { + "address": "0x140004650", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140004650", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x2de61]" + }, + { + "address": "0x140004657", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400030cc", + "name": "", + "blocks": [ + { + "address": "0x1400030cc", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400030cc", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbx" + }, + { + "address": "0x1400030d1", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rbp" + }, + { + "address": "0x1400030d6", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rsi" + }, + { + "address": "0x1400030db", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x1400030dc", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x90" + }, + { + "address": "0x1400030e3", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x1400030e6", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x1400030e9", + "size": 2, + "mnemonic": "xor", + "operands": "esi, esi" + }, + { + "address": "0x1400030eb", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0xa0], esi" + }, + { + "address": "0x1400030f2", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x1400030f5", + "size": 2, + "mnemonic": "je", + "operands": "0x14000316a" + } + ], + "successors": [ + "0x14000316a", + "0x1400030f7" + ] + }, + { + "address": "0x14000316a", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000316a", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 2" + }, + { + "address": "0x14000316f", + "size": 8, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x90]" + }, + { + "address": "0x140003177", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x18]" + }, + { + "address": "0x14000317b", + "size": 4, + "mnemonic": "mov", + "operands": "rbp, qword ptr [r11 + 0x20]" + }, + { + "address": "0x14000317f", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x28]" + }, + { + "address": "0x140003183", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x140003186", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140003187", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400030f7", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400030f7", + "size": 3, + "mnemonic": "cmp", + "operands": "qword ptr [rcx], rsi" + }, + { + "address": "0x1400030fa", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000316a" + }, + { + "address": "0x1400030fc", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rsi + 0x10]" + }, + { + "address": "0x1400030ff", + "size": 5, + "mnemonic": "call", + "operands": "0x140005134" + }, + { + "address": "0x140003104", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x140003107", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0xa0], rax" + }, + { + "address": "0x14000310f", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140003112", + "size": 2, + "mnemonic": "je", + "operands": "0x140003155" + } + ], + "successors": [ + "0x140003155", + "0x140003114" + ] + }, + { + "address": "0x140003155", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140003155", + "size": 2, + "mnemonic": "xor", + "operands": "ebx, ebx" + }, + { + "address": "0x140003157", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rdi], rbx" + }, + { + "address": "0x14000315a", + "size": 4, + "mnemonic": "test", + "operands": "sil, 1" + }, + { + "address": "0x14000315e", + "size": 2, + "mnemonic": "je", + "operands": "0x14000316a" + } + ], + "successors": [ + "0x14000316a", + "0x140003160" + ] + }, + { + "address": "0x140003114", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140003114", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 8]" + }, + { + "address": "0x140003118", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000311b", + "size": 2, + "mnemonic": "je", + "operands": "0x14000312c" + } + ], + "successors": [ + "0x14000312c", + "0x14000311d" + ] + }, + { + "address": "0x140003160", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140003160", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x20]" + }, + { + "address": "0x140003165", + "size": 5, + "mnemonic": "call", + "operands": "0x140002bb8" + }, + { + "address": "0x14000316a", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 2" + }, + { + "address": "0x14000316f", + "size": 8, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x90]" + }, + { + "address": "0x140003177", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x18]" + }, + { + "address": "0x14000317b", + "size": 4, + "mnemonic": "mov", + "operands": "rbp, qword ptr [r11 + 0x20]" + }, + { + "address": "0x14000317f", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x28]" + }, + { + "address": "0x140003183", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x140003186", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140003187", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000312c", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000312c", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x1e34d]" + }, + { + "address": "0x140003133", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x20]" + }, + { + "address": "0x140003138", + "size": 5, + "mnemonic": "call", + "operands": "0x1400029cc" + }, + { + "address": "0x14000313d", + "size": 5, + "mnemonic": "mov", + "operands": "esi, 1" + }, + { + "address": "0x140003142", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 8], 0" + }, + { + "address": "0x140003149", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1e4d8]" + }, + { + "address": "0x140003150", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rbx], rax" + }, + { + "address": "0x140003153", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140003157" + } + ], + "successors": [ + "0x140003157" + ] + }, + { + "address": "0x14000311d", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000311d", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rax + 0x28]" + }, + { + "address": "0x140003121", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x140003124", + "size": 2, + "mnemonic": "jne", + "operands": "0x140003133" + }, + { + "address": "0x140003126", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rax + 0x30]" + }, + { + "address": "0x14000312a", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140003133" + } + ], + "successors": [ + "0x140003133" + ] + }, + { + "address": "0x140003157", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140003157", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rdi], rbx" + }, + { + "address": "0x14000315a", + "size": 4, + "mnemonic": "test", + "operands": "sil, 1" + }, + { + "address": "0x14000315e", + "size": 2, + "mnemonic": "je", + "operands": "0x14000316a" + } + ], + "successors": [ + "0x14000316a", + "0x140003160" + ] + }, + { + "address": "0x140003133", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140003133", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x20]" + }, + { + "address": "0x140003138", + "size": 5, + "mnemonic": "call", + "operands": "0x1400029cc" + }, + { + "address": "0x14000313d", + "size": 5, + "mnemonic": "mov", + "operands": "esi, 1" + }, + { + "address": "0x140003142", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 8], 0" + }, + { + "address": "0x140003149", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1e4d8]" + }, + { + "address": "0x140003150", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rbx], rax" + }, + { + "address": "0x140003153", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140003157" + } + ], + "successors": [ + "0x140003157" + ] + } + ] + }, + { + "address": "0x14000348c", + "name": "", + "blocks": [ + { + "address": "0x14000348c", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000348c", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x48" + }, + { + "address": "0x140003490", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x20]" + }, + { + "address": "0x140003495", + "size": 5, + "mnemonic": "call", + "operands": "0x140002a80" + }, + { + "address": "0x14000349a", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x2ca6f]" + }, + { + "address": "0x1400034a1", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x20]" + }, + { + "address": "0x1400034a6", + "size": 5, + "mnemonic": "call", + "operands": "0x140006198" + }, + { + "address": "0x1400034ab", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140004614", + "name": "", + "blocks": [ + { + "address": "0x140004614", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004614", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140004616", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000461a", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14000461d", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0x10" + }, + { + "address": "0x140004622", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cac0" + }, + { + "address": "0x140004627", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rax" + }, + { + "address": "0x14000462a", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000462d", + "size": 2, + "mnemonic": "je", + "operands": "0x14000464a" + } + ], + "successors": [ + "0x14000464a", + "0x14000462f" + ] + }, + { + "address": "0x14000464a", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000464a", + "size": 5, + "mnemonic": "call", + "operands": "0x14000238c" + }, + { + "address": "0x14000464f", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000462f", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000462f", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x2de72]" + }, + { + "address": "0x140004636", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rdx], rax" + }, + { + "address": "0x140004639", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rdx + 8], rbx" + }, + { + "address": "0x14000463d", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x2de64], rdx" + }, + { + "address": "0x140004644", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140004648", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140004649", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140003188", + "name": "", + "blocks": [ + { + "address": "0x140003188", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140003188", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbx" + }, + { + "address": "0x14000318d", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rbp" + }, + { + "address": "0x140003192", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rsi" + }, + { + "address": "0x140003197", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140003198", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0xb0" + }, + { + "address": "0x14000319f", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x1400031a2", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x1400031a5", + "size": 2, + "mnemonic": "xor", + "operands": "esi, esi" + }, + { + "address": "0x1400031a7", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0xc0], esi" + }, + { + "address": "0x1400031ae", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x1400031b1", + "size": 6, + "mnemonic": "je", + "operands": "0x140003247" + } + ], + "successors": [ + "0x140003247", + "0x1400031b7" + ] + }, + { + "address": "0x140003247", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140003247", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 2" + }, + { + "address": "0x14000324c", + "size": 8, + "mnemonic": "lea", + "operands": "r11, [rsp + 0xb0]" + }, + { + "address": "0x140003254", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x18]" + }, + { + "address": "0x140003258", + "size": 4, + "mnemonic": "mov", + "operands": "rbp, qword ptr [r11 + 0x20]" + }, + { + "address": "0x14000325c", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x28]" + }, + { + "address": "0x140003260", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x140003263", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140003264", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400031b7", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400031b7", + "size": 3, + "mnemonic": "cmp", + "operands": "qword ptr [rcx], rsi" + }, + { + "address": "0x1400031ba", + "size": 6, + "mnemonic": "jne", + "operands": "0x140003247" + }, + { + "address": "0x1400031c0", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rsi + 0x30]" + }, + { + "address": "0x1400031c3", + "size": 5, + "mnemonic": "call", + "operands": "0x140005134" + }, + { + "address": "0x1400031c8", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x1400031cb", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0xc0], rax" + }, + { + "address": "0x1400031d3", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x1400031d6", + "size": 2, + "mnemonic": "je", + "operands": "0x140003232" + } + ], + "successors": [ + "0x140003232", + "0x1400031d8" + ] + }, + { + "address": "0x140003232", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140003232", + "size": 2, + "mnemonic": "xor", + "operands": "ebx, ebx" + }, + { + "address": "0x140003234", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rdi], rbx" + }, + { + "address": "0x140003237", + "size": 4, + "mnemonic": "test", + "operands": "sil, 1" + }, + { + "address": "0x14000323b", + "size": 2, + "mnemonic": "je", + "operands": "0x140003247" + } + ], + "successors": [ + "0x140003247", + "0x14000323d" + ] + }, + { + "address": "0x1400031d8", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400031d8", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 8]" + }, + { + "address": "0x1400031dc", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x1400031df", + "size": 2, + "mnemonic": "je", + "operands": "0x1400031f0" + } + ], + "successors": [ + "0x1400031f0", + "0x1400031e1" + ] + }, + { + "address": "0x14000323d", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000323d", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x40]" + }, + { + "address": "0x140003242", + "size": 5, + "mnemonic": "call", + "operands": "0x140002bb8" + }, + { + "address": "0x140003247", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 2" + }, + { + "address": "0x14000324c", + "size": 8, + "mnemonic": "lea", + "operands": "r11, [rsp + 0xb0]" + }, + { + "address": "0x140003254", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x18]" + }, + { + "address": "0x140003258", + "size": 4, + "mnemonic": "mov", + "operands": "rbp, qword ptr [r11 + 0x20]" + }, + { + "address": "0x14000325c", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x28]" + }, + { + "address": "0x140003260", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x140003263", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140003264", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400031f0", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400031f0", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x1e289]" + }, + { + "address": "0x1400031f7", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x40]" + }, + { + "address": "0x1400031fc", + "size": 5, + "mnemonic": "call", + "operands": "0x1400029cc" + }, + { + "address": "0x140003201", + "size": 5, + "mnemonic": "mov", + "operands": "esi, 1" + }, + { + "address": "0x140003206", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 8], 0" + }, + { + "address": "0x14000320d", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1e27c]" + }, + { + "address": "0x140003214", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rbx], rax" + }, + { + "address": "0x140003217", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x20]" + }, + { + "address": "0x14000321c", + "size": 5, + "mnemonic": "call", + "operands": "0x140004910" + }, + { + "address": "0x140003221", + "size": 3, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rax]" + }, + { + "address": "0x140003224", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rbx + 0x10], xmm0" + }, + { + "address": "0x140003228", + "size": 4, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rax + 0x10]" + }, + { + "address": "0x14000322c", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rbx + 0x20], xmm1" + }, + { + "address": "0x140003230", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140003234" + } + ], + "successors": [ + "0x140003234" + ] + }, + { + "address": "0x1400031e1", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400031e1", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rax + 0x28]" + }, + { + "address": "0x1400031e5", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x1400031e8", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400031f7" + }, + { + "address": "0x1400031ea", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rax + 0x30]" + }, + { + "address": "0x1400031ee", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400031f7" + } + ], + "successors": [ + "0x1400031f7" + ] + }, + { + "address": "0x140003234", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140003234", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rdi], rbx" + }, + { + "address": "0x140003237", + "size": 4, + "mnemonic": "test", + "operands": "sil, 1" + }, + { + "address": "0x14000323b", + "size": 2, + "mnemonic": "je", + "operands": "0x140003247" + } + ], + "successors": [ + "0x140003247", + "0x14000323d" + ] + }, + { + "address": "0x1400031f7", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400031f7", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x40]" + }, + { + "address": "0x1400031fc", + "size": 5, + "mnemonic": "call", + "operands": "0x1400029cc" + }, + { + "address": "0x140003201", + "size": 5, + "mnemonic": "mov", + "operands": "esi, 1" + }, + { + "address": "0x140003206", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 8], 0" + }, + { + "address": "0x14000320d", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1e27c]" + }, + { + "address": "0x140003214", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rbx], rax" + }, + { + "address": "0x140003217", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x20]" + }, + { + "address": "0x14000321c", + "size": 5, + "mnemonic": "call", + "operands": "0x140004910" + }, + { + "address": "0x140003221", + "size": 3, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rax]" + }, + { + "address": "0x140003224", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rbx + 0x10], xmm0" + }, + { + "address": "0x140003228", + "size": 4, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rax + 0x10]" + }, + { + "address": "0x14000322c", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rbx + 0x20], xmm1" + }, + { + "address": "0x140003230", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140003234" + } + ], + "successors": [ + "0x140003234" + ] + } + ] + }, + { + "address": "0x14000cfb8", + "name": "", + "blocks": [ + { + "address": "0x14000cfb8", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000cfb8", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000cfbc", + "size": 5, + "mnemonic": "call", + "operands": "0x1400118c4" + }, + { + "address": "0x14000cfc1", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x30]" + }, + { + "address": "0x14000cfc6", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax + 0x90]" + }, + { + "address": "0x14000cfcd", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rcx" + }, + { + "address": "0x14000cfd2", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x14000cfd5", + "size": 5, + "mnemonic": "call", + "operands": "0x140015b2c" + }, + { + "address": "0x14000cfda", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000cfdf", + "size": 6, + "mnemonic": "add", + "operands": "rax, 0x128" + }, + { + "address": "0x14000cfe5", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000cfe9", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000cf88", + "name": "", + "blocks": [ + { + "address": "0x14000cf88", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000cf88", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000cf8c", + "size": 5, + "mnemonic": "call", + "operands": "0x1400118c4" + }, + { + "address": "0x14000cf91", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x30]" + }, + { + "address": "0x14000cf96", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax + 0x90]" + }, + { + "address": "0x14000cf9d", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rcx" + }, + { + "address": "0x14000cfa2", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x14000cfa5", + "size": 5, + "mnemonic": "call", + "operands": "0x140015b2c" + }, + { + "address": "0x14000cfaa", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000cfaf", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rax + 0xc]" + }, + { + "address": "0x14000cfb2", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000cfb6", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000d9c0", + "name": "", + "blocks": [ + { + "address": "0x14000d9c0", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d9c0", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000d9c2", + "size": 2, + "mnemonic": "cmp", + "operands": "byte ptr [rcx], al" + }, + { + "address": "0x14000d9c4", + "size": 2, + "mnemonic": "je", + "operands": "0x14000d9d4" + } + ], + "successors": [ + "0x14000d9d4", + "0x14000d9c6" + ] + }, + { + "address": "0x14000d9d4", + "size": 1, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000d9d4", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000d9c6", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d9c6", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, rdx" + }, + { + "address": "0x14000d9c9", + "size": 2, + "mnemonic": "je", + "operands": "0x14000d9d4" + } + ], + "successors": [ + "0x14000d9d4", + "0x14000d9cb" + ] + }, + { + "address": "0x14000d9cb", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000d9cb", + "size": 3, + "mnemonic": "inc", + "operands": "rax" + }, + { + "address": "0x14000d9ce", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rax + rcx], 0" + }, + { + "address": "0x14000d9d2", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000d9c6" + }, + { + "address": "0x14000d9d4", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000cac0", + "name": "", + "blocks": [ + { + "address": "0x14000cac0", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000cac0", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140015200" + } + ], + "successors": [ + "0x140015200" + ] + }, + { + "address": "0x140015200", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015200", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140015202", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140015206", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140015209", + "size": 4, + "mnemonic": "cmp", + "operands": "rcx, -0x20" + }, + { + "address": "0x14001520d", + "size": 2, + "mnemonic": "ja", + "operands": "0x14001524b" + } + ], + "successors": [ + "0x14001524b", + "0x14001520f" + ] + }, + { + "address": "0x14001524b", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001524b", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x140015250", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0xc" + }, + { + "address": "0x140015256", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140015258", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001525c", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001525d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001520f", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001520f", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140015212", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 1" + }, + { + "address": "0x140015217", + "size": 4, + "mnemonic": "cmove", + "operands": "rbx, rax" + }, + { + "address": "0x14001521b", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140015232" + } + ], + "successors": [ + "0x140015232" + ] + }, + { + "address": "0x140015232", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015232", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rip + 0x1e61f]" + }, + { + "address": "0x140015239", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rbx" + }, + { + "address": "0x14001523c", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14001523e", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xaf3c]" + }, + { + "address": "0x140015244", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140015247", + "size": 2, + "mnemonic": "je", + "operands": "0x14001521d" + } + ], + "successors": [ + "0x14001521d", + "0x140015249" + ] + }, + { + "address": "0x14001521d", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001521d", + "size": 5, + "mnemonic": "call", + "operands": "0x1400105b0" + }, + { + "address": "0x140015222", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140015224", + "size": 2, + "mnemonic": "je", + "operands": "0x14001524b" + } + ], + "successors": [ + "0x14001524b", + "0x140015226" + ] + }, + { + "address": "0x140015249", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015249", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140015258" + } + ], + "successors": [ + "0x140015258" + ] + }, + { + "address": "0x140015226", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015226", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140015229", + "size": 5, + "mnemonic": "call", + "operands": "0x14000deb0" + }, + { + "address": "0x14001522e", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140015230", + "size": 2, + "mnemonic": "je", + "operands": "0x14001524b" + } + ], + "successors": [ + "0x14001524b", + "0x140015232" + ] + }, + { + "address": "0x140015258", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140015258", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001525c", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001525d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400057a0", + "name": "", + "blocks": [ + { + "address": "0x1400057a0", + "size": 19, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400057a0", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x10" + }, + { + "address": "0x1400057a4", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rsp], r10" + }, + { + "address": "0x1400057a8", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], r11" + }, + { + "address": "0x1400057ad", + "size": 3, + "mnemonic": "xor", + "operands": "r11, r11" + }, + { + "address": "0x1400057b0", + "size": 5, + "mnemonic": "lea", + "operands": "r10, [rsp + 0x18]" + }, + { + "address": "0x1400057b5", + "size": 3, + "mnemonic": "sub", + "operands": "r10, rax" + }, + { + "address": "0x1400057b8", + "size": 4, + "mnemonic": "cmovb", + "operands": "r10, r11" + }, + { + "address": "0x1400057bc", + "size": 9, + "mnemonic": "mov", + "operands": "r11, qword ptr gs:[0x10]" + }, + { + "address": "0x1400057c5", + "size": 3, + "mnemonic": "cmp", + "operands": "r10, r11" + }, + { + "address": "0x1400057c8", + "size": 2, + "mnemonic": "jae", + "operands": "0x1400057e0" + }, + { + "address": "0x1400057ca", + "size": 6, + "mnemonic": "and", + "operands": "r10w, 0xf000" + }, + { + "address": "0x1400057d0", + "size": 7, + "mnemonic": "lea", + "operands": "r11, [r11 - 0x1000]" + }, + { + "address": "0x1400057d7", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [r11], 0" + }, + { + "address": "0x1400057db", + "size": 3, + "mnemonic": "cmp", + "operands": "r10, r11" + }, + { + "address": "0x1400057de", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400057d0" + }, + { + "address": "0x1400057e0", + "size": 4, + "mnemonic": "mov", + "operands": "r10, qword ptr [rsp]" + }, + { + "address": "0x1400057e4", + "size": 5, + "mnemonic": "mov", + "operands": "r11, qword ptr [rsp + 8]" + }, + { + "address": "0x1400057e9", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x10" + }, + { + "address": "0x1400057ed", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000c9d0", + "name": "", + "blocks": [ + ] + }, + { + "address": "0x140006544", + "name": "", + "blocks": [ + { + "address": "0x140006544", + "size": 20, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006544", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbx" + }, + { + "address": "0x140006549", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rbp" + }, + { + "address": "0x14000654e", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rsi" + }, + { + "address": "0x140006553", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140006554", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140006556", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140006558", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000655a", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14000655c", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140006560", + "size": 4, + "mnemonic": "mov", + "operands": "ebp, dword ptr [r8 + 0xc]" + }, + { + "address": "0x140006564", + "size": 3, + "mnemonic": "mov", + "operands": "r13, rcx" + }, + { + "address": "0x140006567", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r8" + }, + { + "address": "0x14000656a", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, r9" + }, + { + "address": "0x14000656d", + "size": 3, + "mnemonic": "mov", + "operands": "r15, r8" + }, + { + "address": "0x140006570", + "size": 3, + "mnemonic": "mov", + "operands": "r12, rdx" + }, + { + "address": "0x140006573", + "size": 5, + "mnemonic": "call", + "operands": "0x1400075d8" + }, + { + "address": "0x140006578", + "size": 4, + "mnemonic": "mov", + "operands": "r10, qword ptr [r13]" + }, + { + "address": "0x14000657c", + "size": 3, + "mnemonic": "mov", + "operands": "r14d, eax" + }, + { + "address": "0x14000657f", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rsi], r10" + }, + { + "address": "0x140006582", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400065ef" + } + ], + "successors": [ + "0x1400065ef" + ] + }, + { + "address": "0x1400065ef", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400065ef", + "size": 2, + "mnemonic": "test", + "operands": "ebp, ebp" + }, + { + "address": "0x1400065f1", + "size": 2, + "mnemonic": "jne", + "operands": "0x140006584" + }, + { + "address": "0x1400065f3", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140006609" + } + ], + "successors": [ + "0x140006609" + ] + }, + { + "address": "0x140006609", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140006609", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x58]" + }, + { + "address": "0x14000660e", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsi" + }, + { + "address": "0x140006611", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x68]" + }, + { + "address": "0x140006616", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14000661b", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000661f", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140006621", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140006623", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140006625", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140006627", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140006628", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140006da8", + "name": "", + "blocks": [ + { + "address": "0x140006da8", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140006da8", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x140006dac", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140006db1", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax + 0x60]" + }, + { + "address": "0x140006db5", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x140006db9", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140007b2c", + "name": "", + "blocks": [ + { + "address": "0x140007b2c", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007b2c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140007b31", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rsi" + }, + { + "address": "0x140007b36", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rdi" + }, + { + "address": "0x140007b3b", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140007b3d", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140007b41", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, r9" + }, + { + "address": "0x140007b44", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rcx" + }, + { + "address": "0x140007b47", + "size": 2, + "mnemonic": "xor", + "operands": "ebx, ebx" + }, + { + "address": "0x140007b49", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [r8], ebx" + }, + { + "address": "0x140007b4c", + "size": 2, + "mnemonic": "jge", + "operands": "0x140007b53" + }, + { + "address": "0x140007b4e", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x140007b51", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140007b5a" + } + ], + "successors": [ + "0x140007b5a" + ] + }, + { + "address": "0x140007b5a", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007b5a", + "size": 5, + "mnemonic": "call", + "operands": "0x140007740" + }, + { + "address": "0x140007b5f", + "size": 3, + "mnemonic": "sub", + "operands": "eax, 1" + }, + { + "address": "0x140007b62", + "size": 2, + "mnemonic": "je", + "operands": "0x140007ba0" + } + ], + "successors": [ + "0x140007ba0", + "0x140007b64" + ] + }, + { + "address": "0x140007ba0", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007ba0", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rsi + 8]" + }, + { + "address": "0x140007ba4", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r14 + 0x28]" + }, + { + "address": "0x140007ba8", + "size": 5, + "mnemonic": "call", + "operands": "0x140007040" + }, + { + "address": "0x140007bad", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rax" + }, + { + "address": "0x140007bb0", + "size": 4, + "mnemonic": "movsxd", + "operands": "rsi, dword ptr [rsi + 0x18]" + }, + { + "address": "0x140007bb4", + "size": 2, + "mnemonic": "test", + "operands": "esi, esi" + }, + { + "address": "0x140007bb6", + "size": 2, + "mnemonic": "je", + "operands": "0x140007bc1" + } + ], + "successors": [ + "0x140007bc1", + "0x140007bb8" + ] + }, + { + "address": "0x140007b64", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007b64", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x140007b67", + "size": 2, + "mnemonic": "jne", + "operands": "0x140007bd0" + }, + { + "address": "0x140007b69", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rsi + 8]" + }, + { + "address": "0x140007b6d", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r14 + 0x28]" + }, + { + "address": "0x140007b71", + "size": 5, + "mnemonic": "call", + "operands": "0x140007040" + }, + { + "address": "0x140007b76", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rax" + }, + { + "address": "0x140007b79", + "size": 4, + "mnemonic": "movsxd", + "operands": "rsi, dword ptr [rsi + 0x18]" + }, + { + "address": "0x140007b7d", + "size": 2, + "mnemonic": "test", + "operands": "esi, esi" + }, + { + "address": "0x140007b7f", + "size": 2, + "mnemonic": "je", + "operands": "0x140007b8a" + } + ], + "successors": [ + "0x140007b8a", + "0x140007b81" + ] + }, + { + "address": "0x140007bc1", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140007bc1", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x140007bc4", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x140007bc7", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140007bca", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a504" + }, + { + "address": "0x140007bcf", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140007bd0", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140007bd5", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x38]" + }, + { + "address": "0x140007bda", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140007bdf", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140007be3", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140007be5", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140007bb8", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140007bb8", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x140007bbd", + "size": 4, + "mnemonic": "lea", + "operands": "rbx, [rax + rsi]" + }, + { + "address": "0x140007bc1", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x140007bc4", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x140007bc7", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140007bca", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a504" + }, + { + "address": "0x140007bcf", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140007bd0", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140007bd5", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x38]" + }, + { + "address": "0x140007bda", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140007bdf", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140007be3", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140007be5", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140007b8a", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007b8a", + "size": 6, + "mnemonic": "mov", + "operands": "r9d, 1" + }, + { + "address": "0x140007b90", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x140007b93", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x140007b96", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140007b99", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a510" + }, + { + "address": "0x140007b9e", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140007bd0" + } + ], + "successors": [ + "0x140007bd0" + ] + }, + { + "address": "0x140007b81", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007b81", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x140007b86", + "size": 4, + "mnemonic": "lea", + "operands": "rbx, [rax + rsi]" + }, + { + "address": "0x140007b8a", + "size": 6, + "mnemonic": "mov", + "operands": "r9d, 1" + }, + { + "address": "0x140007b90", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x140007b93", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x140007b96", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140007b99", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a510" + }, + { + "address": "0x140007b9e", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140007bd0" + } + ], + "successors": [ + "0x140007bd0" + ] + }, + { + "address": "0x140007bd0", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140007bd0", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140007bd5", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x38]" + }, + { + "address": "0x140007bda", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140007bdf", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140007be3", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140007be5", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000662c", + "name": "", + "blocks": [ + { + "address": "0x14000662c", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000662c", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x14000662f", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rcx" + }, + { + "address": "0x140006632", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [r9], rax" + }, + { + "address": "0x140006635", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [r8], 1" + }, + { + "address": "0x140006639", + "size": 2, + "mnemonic": "je", + "operands": "0x140006649" + } + ], + "successors": [ + "0x140006649", + "0x14000663b" + ] + }, + { + "address": "0x140006649", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140006649", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r9" + }, + { + "address": "0x14000664c", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000663b", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000663b", + "size": 4, + "mnemonic": "mov", + "operands": "ecx, dword ptr [r8 + 0x14]" + }, + { + "address": "0x14000663f", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdx]" + }, + { + "address": "0x140006642", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + rax]" + }, + { + "address": "0x140006646", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [r9], rcx" + }, + { + "address": "0x140006649", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r9" + }, + { + "address": "0x14000664c", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140007bec", + "name": "", + "blocks": [ + { + "address": "0x140007bec", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007bec", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140007bf1", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rsi" + }, + { + "address": "0x140007bf6", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rdi" + }, + { + "address": "0x140007bfb", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140007bfd", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140007c01", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, r9" + }, + { + "address": "0x140007c04", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rcx" + }, + { + "address": "0x140007c07", + "size": 2, + "mnemonic": "xor", + "operands": "ebx, ebx" + }, + { + "address": "0x140007c09", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [r8 + 4], ebx" + }, + { + "address": "0x140007c0d", + "size": 2, + "mnemonic": "jge", + "operands": "0x140007c14" + }, + { + "address": "0x140007c0f", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x140007c12", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140007c1b" + } + ], + "successors": [ + "0x140007c1b" + ] + }, + { + "address": "0x140007c1b", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007c1b", + "size": 5, + "mnemonic": "call", + "operands": "0x140007934" + }, + { + "address": "0x140007c20", + "size": 3, + "mnemonic": "sub", + "operands": "eax, 1" + }, + { + "address": "0x140007c23", + "size": 2, + "mnemonic": "je", + "operands": "0x140007c61" + } + ], + "successors": [ + "0x140007c61", + "0x140007c25" + ] + }, + { + "address": "0x140007c61", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007c61", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rsi + 8]" + }, + { + "address": "0x140007c65", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r14 + 0x28]" + }, + { + "address": "0x140007c69", + "size": 5, + "mnemonic": "call", + "operands": "0x140007040" + }, + { + "address": "0x140007c6e", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rax" + }, + { + "address": "0x140007c71", + "size": 4, + "mnemonic": "movsxd", + "operands": "rsi, dword ptr [rsi + 0x18]" + }, + { + "address": "0x140007c75", + "size": 2, + "mnemonic": "test", + "operands": "esi, esi" + }, + { + "address": "0x140007c77", + "size": 2, + "mnemonic": "je", + "operands": "0x140007c82" + } + ], + "successors": [ + "0x140007c82", + "0x140007c79" + ] + }, + { + "address": "0x140007c25", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007c25", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x140007c28", + "size": 2, + "mnemonic": "jne", + "operands": "0x140007c91" + }, + { + "address": "0x140007c2a", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rsi + 8]" + }, + { + "address": "0x140007c2e", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r14 + 0x28]" + }, + { + "address": "0x140007c32", + "size": 5, + "mnemonic": "call", + "operands": "0x140007040" + }, + { + "address": "0x140007c37", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rax" + }, + { + "address": "0x140007c3a", + "size": 4, + "mnemonic": "movsxd", + "operands": "rsi, dword ptr [rsi + 0x18]" + }, + { + "address": "0x140007c3e", + "size": 2, + "mnemonic": "test", + "operands": "esi, esi" + }, + { + "address": "0x140007c40", + "size": 2, + "mnemonic": "je", + "operands": "0x140007c4b" + } + ], + "successors": [ + "0x140007c4b", + "0x140007c42" + ] + }, + { + "address": "0x140007c82", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140007c82", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x140007c85", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x140007c88", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140007c8b", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a504" + }, + { + "address": "0x140007c90", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140007c91", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140007c96", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x38]" + }, + { + "address": "0x140007c9b", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140007ca0", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140007ca4", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140007ca6", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140007c79", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140007c79", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x140007c7e", + "size": 4, + "mnemonic": "lea", + "operands": "rbx, [rax + rsi]" + }, + { + "address": "0x140007c82", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x140007c85", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x140007c88", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140007c8b", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a504" + }, + { + "address": "0x140007c90", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140007c91", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140007c96", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x38]" + }, + { + "address": "0x140007c9b", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140007ca0", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140007ca4", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140007ca6", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140007c4b", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007c4b", + "size": 6, + "mnemonic": "mov", + "operands": "r9d, 1" + }, + { + "address": "0x140007c51", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x140007c54", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x140007c57", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140007c5a", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a510" + }, + { + "address": "0x140007c5f", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140007c91" + } + ], + "successors": [ + "0x140007c91" + ] + }, + { + "address": "0x140007c42", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007c42", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x140007c47", + "size": 4, + "mnemonic": "lea", + "operands": "rbx, [rax + rsi]" + }, + { + "address": "0x140007c4b", + "size": 6, + "mnemonic": "mov", + "operands": "r9d, 1" + }, + { + "address": "0x140007c51", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r14" + }, + { + "address": "0x140007c54", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x140007c57", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140007c5a", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a510" + }, + { + "address": "0x140007c5f", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140007c91" + } + ], + "successors": [ + "0x140007c91" + ] + }, + { + "address": "0x140007c91", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140007c91", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140007c96", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x38]" + }, + { + "address": "0x140007c9b", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140007ca0", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140007ca4", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140007ca6", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000a25c", + "name": "", + "blocks": [ + { + "address": "0x14000a25c", + "size": 32, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a25c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000a261", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x14000a266", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x14000a26b", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000a26c", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a270", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rcx" + }, + { + "address": "0x14000a273", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r8" + }, + { + "address": "0x14000a276", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r8" + }, + { + "address": "0x14000a279", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rdx" + }, + { + "address": "0x14000a27c", + "size": 5, + "mnemonic": "call", + "operands": "0x1400075d8" + }, + { + "address": "0x14000a281", + "size": 5, + "mnemonic": "lea", + "operands": "r9, [rsp + 0x48]" + }, + { + "address": "0x14000a286", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rdi" + }, + { + "address": "0x14000a289", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x14000a28c", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbp" + }, + { + "address": "0x14000a28f", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, eax" + }, + { + "address": "0x14000a291", + "size": 5, + "mnemonic": "call", + "operands": "0x140006544" + }, + { + "address": "0x14000a296", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rdi" + }, + { + "address": "0x14000a299", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x14000a29c", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbp" + }, + { + "address": "0x14000a29f", + "size": 5, + "mnemonic": "call", + "operands": "0x140007564" + }, + { + "address": "0x14000a2a4", + "size": 2, + "mnemonic": "cmp", + "operands": "ebx, eax" + }, + { + "address": "0x14000a2a6", + "size": 2, + "mnemonic": "jle", + "operands": "0x14000a2cb" + }, + { + "address": "0x14000a2a8", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, ebx" + }, + { + "address": "0x14000a2ab", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x48]" + }, + { + "address": "0x14000a2b0", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rdi" + }, + { + "address": "0x14000a2b3", + "size": 5, + "mnemonic": "call", + "operands": "0x140007590" + }, + { + "address": "0x14000a2b8", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, ebx" + }, + { + "address": "0x14000a2bb", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rdi" + }, + { + "address": "0x14000a2be", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x14000a2c1", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbp" + }, + { + "address": "0x14000a2c4", + "size": 5, + "mnemonic": "call", + "operands": "0x14000759c" + }, + { + "address": "0x14000a2c9", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000a2db" + } + ], + "successors": [ + "0x14000a2db" + ] + }, + { + "address": "0x14000a2db", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000a2db", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14000a2e0", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ebx" + }, + { + "address": "0x14000a2e2", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000a2e7", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14000a2ec", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a2f0", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000a2f1", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000d6d0", + "name": "", + "blocks": [ + { + "address": "0x14000d6d0", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d6d0", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000d6d4", + "size": 5, + "mnemonic": "call", + "operands": "0x14001667c" + }, + { + "address": "0x14000d6d9", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000d6dc", + "size": 2, + "mnemonic": "je", + "operands": "0x14000d6e8" + } + ], + "successors": [ + "0x14000d6e8", + "0x14000d6de" + ] + }, + { + "address": "0x14000d6e8", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d6e8", + "size": 7, + "mnemonic": "test", + "operands": "byte ptr [rip + 0x23af9], 2" + }, + { + "address": "0x14000d6ef", + "size": 2, + "mnemonic": "je", + "operands": "0x14000d71b" + } + ], + "successors": [ + "0x14000d71b", + "0x14000d6f1" + ] + }, + { + "address": "0x14000d6de", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d6de", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0x16" + }, + { + "address": "0x14000d6e3", + "size": 5, + "mnemonic": "call", + "operands": "0x1400166cc" + }, + { + "address": "0x14000d6e8", + "size": 7, + "mnemonic": "test", + "operands": "byte ptr [rip + 0x23af9], 2" + }, + { + "address": "0x14000d6ef", + "size": 2, + "mnemonic": "je", + "operands": "0x14000d71b" + } + ], + "successors": [ + "0x14000d71b", + "0x14000d6f1" + ] + }, + { + "address": "0x14000d71b", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d71b", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 3" + }, + { + "address": "0x14000d720", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ebcc" + }, + { + "address": "0x14000d725", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000d6f1", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d6f1", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0x17" + }, + { + "address": "0x14000d6f6", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x12994]" + }, + { + "address": "0x14000d6fc", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000d6fe", + "size": 2, + "mnemonic": "je", + "operands": "0x14000d707" + } + ], + "successors": [ + "0x14000d707", + "0x14000d700" + ] + }, + { + "address": "0x14000d707", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d707", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 1" + }, + { + "address": "0x14000d70d", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0x40000015" + }, + { + "address": "0x14000d712", + "size": 4, + "mnemonic": "lea", + "operands": "ecx, [r8 + 2]" + }, + { + "address": "0x14000d716", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ace8" + }, + { + "address": "0x14000d71b", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 3" + }, + { + "address": "0x14000d720", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ebcc" + }, + { + "address": "0x14000d725", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000d700", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d700", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 7" + }, + { + "address": "0x14000d705", + "size": 2, + "mnemonic": "int", + "operands": "0x29" + }, + { + "address": "0x14000d707", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 1" + }, + { + "address": "0x14000d70d", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0x40000015" + }, + { + "address": "0x14000d712", + "size": 4, + "mnemonic": "lea", + "operands": "ecx, [r8 + 2]" + }, + { + "address": "0x14000d716", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ace8" + }, + { + "address": "0x14000d71b", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 3" + }, + { + "address": "0x14000d720", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ebcc" + }, + { + "address": "0x14000d725", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140007394", + "name": "", + "blocks": [ + { + "address": "0x140007394", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007394", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x140007398", + "size": 5, + "mnemonic": "call", + "operands": "0x1400073b0" + }, + { + "address": "0x14000739d", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x1400073a0", + "size": 2, + "mnemonic": "je", + "operands": "0x1400073a7" + } + ], + "successors": [ + "0x1400073a7", + "0x1400073a2" + ] + }, + { + "address": "0x1400073a7", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400073a7", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x1400073ac", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400073a2", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400073a2", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400073a6", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140006de8", + "name": "", + "blocks": [ + { + "address": "0x140006de8", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140006de8", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140006dea", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140006dee", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140006df1", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140006df6", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x68], rbx" + }, + { + "address": "0x140006dfa", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140006dfe", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140006dff", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140006650", + "name": "", + "blocks": [ + { + "address": "0x140006650", + "size": 22, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006650", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140006655", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x14000665a", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x14000665f", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140006660", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140006662", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140006664", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140006666", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140006668", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x14000666c", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x90]" + }, + { + "address": "0x140006674", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rdx" + }, + { + "address": "0x140006677", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rcx" + }, + { + "address": "0x14000667a", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r9" + }, + { + "address": "0x14000667d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140006680", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r9" + }, + { + "address": "0x140006683", + "size": 3, + "mnemonic": "mov", + "operands": "r14d, r8d" + }, + { + "address": "0x140006686", + "size": 3, + "mnemonic": "mov", + "operands": "ebp, dword ptr [rbx + 0xc]" + }, + { + "address": "0x140006689", + "size": 5, + "mnemonic": "call", + "operands": "0x1400075d8" + }, + { + "address": "0x14000668e", + "size": 3, + "mnemonic": "xor", + "operands": "r10d, r10d" + }, + { + "address": "0x140006691", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, eax" + }, + { + "address": "0x140006694", + "size": 2, + "mnemonic": "test", + "operands": "ebp, ebp" + }, + { + "address": "0x140006696", + "size": 6, + "mnemonic": "je", + "operands": "0x140006780" + } + ], + "successors": [ + "0x140006780", + "0x14000669c" + ] + }, + { + "address": "0x140006780", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006780", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140006785", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000669c", + "size": 22, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000669c", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rdi + 8]" + }, + { + "address": "0x1400066a0", + "size": 4, + "mnemonic": "or", + "operands": "r12d, 0xffffffff" + }, + { + "address": "0x1400066a4", + "size": 4, + "mnemonic": "movsxd", + "operands": "r11, dword ptr [rbx + 0x10]" + }, + { + "address": "0x1400066a8", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, r12d" + }, + { + "address": "0x1400066ab", + "size": 3, + "mnemonic": "mov", + "operands": "r13d, r12d" + }, + { + "address": "0x1400066ae", + "size": 2, + "mnemonic": "mov", + "operands": "edx, ebp" + }, + { + "address": "0x1400066b0", + "size": 3, + "mnemonic": "lea", + "operands": "eax, [rdx - 1]" + }, + { + "address": "0x1400066b3", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + rax*4]" + }, + { + "address": "0x1400066b7", + "size": 2, + "mnemonic": "lea", + "operands": "ebx, [rdx]" + }, + { + "address": "0x1400066b9", + "size": 2, + "mnemonic": "mov", + "operands": "edx, eax" + }, + { + "address": "0x1400066bb", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rdi + rcx*4]" + }, + { + "address": "0x1400066bf", + "size": 5, + "mnemonic": "cmp", + "operands": "r9d, dword ptr [rax + r11 + 4]" + }, + { + "address": "0x1400066c4", + "size": 2, + "mnemonic": "jle", + "operands": "0x1400066d1" + }, + { + "address": "0x1400066c6", + "size": 5, + "mnemonic": "cmp", + "operands": "r9d, dword ptr [rax + r11 + 8]" + }, + { + "address": "0x1400066cb", + "size": 6, + "mnemonic": "jle", + "operands": "0x14000676d" + }, + { + "address": "0x1400066d1", + "size": 2, + "mnemonic": "test", + "operands": "edx, edx" + }, + { + "address": "0x1400066d3", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400066b0" + }, + { + "address": "0x1400066d5", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r10" + }, + { + "address": "0x1400066d8", + "size": 3, + "mnemonic": "mov", + "operands": "edx, r10d" + }, + { + "address": "0x1400066db", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rdi + r11]" + }, + { + "address": "0x1400066df", + "size": 3, + "mnemonic": "test", + "operands": "r9, r9" + }, + { + "address": "0x1400066e2", + "size": 2, + "mnemonic": "je", + "operands": "0x1400066f5" + } + ], + "successors": [ + "0x1400066f5", + "0x1400066e4" + ] + }, + { + "address": "0x1400066f5", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400066f5", + "size": 3, + "mnemonic": "cmp", + "operands": "r14d, dword ptr [rcx]" + }, + { + "address": "0x1400066f8", + "size": 2, + "mnemonic": "jl", + "operands": "0x14000670a" + } + ], + "successors": [ + "0x14000670a", + "0x1400066fa" + ] + }, + { + "address": "0x1400066e4", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400066e4", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r9 + 4]" + }, + { + "address": "0x1400066e8", + "size": 2, + "mnemonic": "cmp", + "operands": "dword ptr [rcx], eax" + }, + { + "address": "0x1400066ea", + "size": 2, + "mnemonic": "jle", + "operands": "0x14000670a" + }, + { + "address": "0x1400066ec", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r9 + 8]" + }, + { + "address": "0x1400066f0", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rcx + 4], eax" + }, + { + "address": "0x1400066f3", + "size": 2, + "mnemonic": "jg", + "operands": "0x14000670a" + } + ], + "successors": [ + "0x14000670a", + "0x1400066f5" + ] + }, + { + "address": "0x14000670a", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000670a", + "size": 2, + "mnemonic": "inc", + "operands": "edx" + }, + { + "address": "0x14000670c", + "size": 4, + "mnemonic": "add", + "operands": "rcx, 0x14" + }, + { + "address": "0x140006710", + "size": 2, + "mnemonic": "cmp", + "operands": "edx, ebp" + }, + { + "address": "0x140006712", + "size": 2, + "mnemonic": "jb", + "operands": "0x1400066df" + } + ], + "successors": [ + "0x1400066df", + "0x140006714" + ] + }, + { + "address": "0x1400066fa", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400066fa", + "size": 4, + "mnemonic": "cmp", + "operands": "r14d, dword ptr [rcx + 4]" + }, + { + "address": "0x1400066fe", + "size": 2, + "mnemonic": "jg", + "operands": "0x14000670a" + } + ], + "successors": [ + "0x14000670a", + "0x140006700" + ] + }, + { + "address": "0x1400066df", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400066df", + "size": 3, + "mnemonic": "test", + "operands": "r9, r9" + }, + { + "address": "0x1400066e2", + "size": 2, + "mnemonic": "je", + "operands": "0x1400066f5" + } + ], + "successors": [ + "0x1400066f5", + "0x1400066e4" + ] + }, + { + "address": "0x140006714", + "size": 25, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140006714", + "size": 3, + "mnemonic": "mov", + "operands": "eax, r10d" + }, + { + "address": "0x140006717", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r15" + }, + { + "address": "0x14000671c", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x40]" + }, + { + "address": "0x140006721", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], r15" + }, + { + "address": "0x140006726", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x30]" + }, + { + "address": "0x14000672a", + "size": 3, + "mnemonic": "cmp", + "operands": "r8d, r12d" + }, + { + "address": "0x14000672d", + "size": 4, + "mnemonic": "mov", + "operands": "rbp, qword ptr [r11 + 0x38]" + }, + { + "address": "0x140006731", + "size": 4, + "mnemonic": "cmovne", + "operands": "eax, r8d" + }, + { + "address": "0x140006735", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], eax" + }, + { + "address": "0x140006739", + "size": 4, + "mnemonic": "lea", + "operands": "eax, [r13 + 1]" + }, + { + "address": "0x14000673d", + "size": 5, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rsp + 0x20]" + }, + { + "address": "0x140006742", + "size": 4, + "mnemonic": "cmovne", + "operands": "r10d, eax" + }, + { + "address": "0x140006746", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsi" + }, + { + "address": "0x140006749", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x38], r10d" + }, + { + "address": "0x14000674e", + "size": 5, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rsp + 0x30]" + }, + { + "address": "0x140006753", + "size": 4, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rsi], xmm0" + }, + { + "address": "0x140006757", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rsi + 0x10], xmm1" + }, + { + "address": "0x14000675c", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x40]" + }, + { + "address": "0x140006760", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x140006763", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140006765", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140006767", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140006769", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14000676b", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000676c", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140006700", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006700", + "size": 3, + "mnemonic": "cmp", + "operands": "r8d, r12d" + }, + { + "address": "0x140006703", + "size": 3, + "mnemonic": "mov", + "operands": "r13d, edx" + }, + { + "address": "0x140006706", + "size": 4, + "mnemonic": "cmove", + "operands": "r8d, edx" + }, + { + "address": "0x14000670a", + "size": 2, + "mnemonic": "inc", + "operands": "edx" + }, + { + "address": "0x14000670c", + "size": 4, + "mnemonic": "add", + "operands": "rcx, 0x14" + }, + { + "address": "0x140006710", + "size": 2, + "mnemonic": "cmp", + "operands": "edx, ebp" + }, + { + "address": "0x140006712", + "size": 2, + "mnemonic": "jb", + "operands": "0x1400066df" + } + ], + "successors": [ + "0x1400066df", + "0x140006714" + ] + } + ] + }, + { + "address": "0x140008888", + "name": "", + "blocks": [ + { + "address": "0x140008888", + "size": 17, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008888", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rbx" + }, + { + "address": "0x14000888d", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], r8" + }, + { + "address": "0x140008892", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rdx" + }, + { + "address": "0x140008897", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140008898", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140008899", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000889a", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x14000889c", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x14000889e", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x1400088a0", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x1400088a2", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0xc0" + }, + { + "address": "0x1400088a9", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rcx], 0x80000003" + }, + { + "address": "0x1400088af", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, r9" + }, + { + "address": "0x1400088b2", + "size": 3, + "mnemonic": "mov", + "operands": "r15, r8" + }, + { + "address": "0x1400088b5", + "size": 3, + "mnemonic": "mov", + "operands": "r12, rdx" + }, + { + "address": "0x1400088b8", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rcx" + }, + { + "address": "0x1400088bb", + "size": 6, + "mnemonic": "je", + "operands": "0x140008ac8" + } + ], + "successors": [ + "0x140008ac8", + "0x1400088c1" + ] + } + ] + }, + { + "address": "0x14000a2f4", + "name": "", + "blocks": [ + { + "address": "0x14000a2f4", + "size": 14, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a2f4", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rbx" + }, + { + "address": "0x14000a2f9", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rcx" + }, + { + "address": "0x14000a2fe", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000a2ff", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x14000a300", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000a301", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x14000a303", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x14000a305", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000a307", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14000a309", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a30d", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rdx" + }, + { + "address": "0x14000a310", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rcx" + }, + { + "address": "0x14000a313", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14000a316", + "size": 6, + "mnemonic": "je", + "operands": "0x14000a3d5" + } + ], + "successors": [ + "0x14000a3d5", + "0x14000a31c" + ] + } + ] + }, + { + "address": "0x14000a3dc", + "name": "", + "blocks": [ + { + "address": "0x14000a3dc", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a3dc", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000a3e1", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x14000a3e6", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x14000a3eb", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000a3ec", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a3f0", + "size": 2, + "mnemonic": "xor", + "operands": "ebp, ebp" + }, + { + "address": "0x14000a3f2", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x14000a3f5", + "size": 2, + "mnemonic": "cmp", + "operands": "dword ptr [rcx], ebp" + }, + { + "address": "0x14000a3f7", + "size": 2, + "mnemonic": "jle", + "operands": "0x14000a449" + }, + { + "address": "0x14000a3f9", + "size": 2, + "mnemonic": "xor", + "operands": "esi, esi" + }, + { + "address": "0x14000a3fb", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rdi + 4]" + }, + { + "address": "0x14000a3ff", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x14000a404", + "size": 3, + "mnemonic": "add", + "operands": "rax, rsi" + }, + { + "address": "0x14000a407", + "size": 5, + "mnemonic": "cmp", + "operands": "dword ptr [rax + rbx + 4], 0" + }, + { + "address": "0x14000a40c", + "size": 2, + "mnemonic": "je", + "operands": "0x14000a429" + } + ], + "successors": [ + "0x14000a429", + "0x14000a40e" + ] + }, + { + "address": "0x14000a429", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a429", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000a42b", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + 8]" + }, + { + "address": "0x14000a42f", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x27a02]" + }, + { + "address": "0x14000a436", + "size": 5, + "mnemonic": "call", + "operands": "0x14000735c" + }, + { + "address": "0x14000a43b", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000a43d", + "size": 2, + "mnemonic": "je", + "operands": "0x14000a460" + } + ], + "successors": [ + "0x14000a460", + "0x14000a43f" + ] + }, + { + "address": "0x14000a40e", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a40e", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rdi + 4]" + }, + { + "address": "0x14000a412", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x14000a417", + "size": 3, + "mnemonic": "add", + "operands": "rax, rsi" + }, + { + "address": "0x14000a41a", + "size": 5, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rax + rbx + 4]" + }, + { + "address": "0x14000a41f", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x14000a424", + "size": 3, + "mnemonic": "add", + "operands": "rax, rbx" + }, + { + "address": "0x14000a427", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000a42b" + } + ], + "successors": [ + "0x14000a42b" + ] + }, + { + "address": "0x14000a460", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a460", + "size": 2, + "mnemonic": "mov", + "operands": "al, 1" + }, + { + "address": "0x14000a462", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000a44b" + } + ], + "successors": [ + "0x14000a44b" + ] + }, + { + "address": "0x14000a43f", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a43f", + "size": 2, + "mnemonic": "inc", + "operands": "ebp" + }, + { + "address": "0x14000a441", + "size": 4, + "mnemonic": "add", + "operands": "rsi, 0x14" + }, + { + "address": "0x14000a445", + "size": 2, + "mnemonic": "cmp", + "operands": "ebp, dword ptr [rdi]" + }, + { + "address": "0x14000a447", + "size": 2, + "mnemonic": "jl", + "operands": "0x14000a3fb" + } + ], + "successors": [ + "0x14000a3fb", + "0x14000a449" + ] + }, + { + "address": "0x14000a42b", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a42b", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + 8]" + }, + { + "address": "0x14000a42f", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x27a02]" + }, + { + "address": "0x14000a436", + "size": 5, + "mnemonic": "call", + "operands": "0x14000735c" + }, + { + "address": "0x14000a43b", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000a43d", + "size": 2, + "mnemonic": "je", + "operands": "0x14000a460" + } + ], + "successors": [ + "0x14000a460", + "0x14000a43f" + ] + }, + { + "address": "0x14000a44b", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000a44b", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000a450", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14000a455", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14000a45a", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a45e", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000a45f", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000a3fb", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a3fb", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rdi + 4]" + }, + { + "address": "0x14000a3ff", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x14000a404", + "size": 3, + "mnemonic": "add", + "operands": "rax, rsi" + }, + { + "address": "0x14000a407", + "size": 5, + "mnemonic": "cmp", + "operands": "dword ptr [rax + rbx + 4], 0" + }, + { + "address": "0x14000a40c", + "size": 2, + "mnemonic": "je", + "operands": "0x14000a429" + } + ], + "successors": [ + "0x14000a429", + "0x14000a40e" + ] + }, + { + "address": "0x14000a449", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000a449", + "size": 2, + "mnemonic": "xor", + "operands": "al, al" + }, + { + "address": "0x14000a44b", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000a450", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14000a455", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14000a45a", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a45e", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000a45f", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140006dbc", + "name": "", + "blocks": [ + { + "address": "0x140006dbc", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140006dbc", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x140006dc0", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140006dc5", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax + 0x68]" + }, + { + "address": "0x140006dc9", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x140006dcd", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140008df4", + "name": "", + "blocks": [ + { + "address": "0x140008df4", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008df4", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140008df9", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x140008dfe", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x140008e03", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140008e04", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140008e06", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140008e08", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140008e0c", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rcx + 4]" + }, + { + "address": "0x140008e10", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x140008e12", + "size": 3, + "mnemonic": "mov", + "operands": "r15, r8" + }, + { + "address": "0x140008e15", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rdx" + }, + { + "address": "0x140008e18", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rcx" + }, + { + "address": "0x140008e1b", + "size": 2, + "mnemonic": "test", + "operands": "ebx, ebx" + }, + { + "address": "0x140008e1d", + "size": 6, + "mnemonic": "je", + "operands": "0x140008ef5" + } + ], + "successors": [ + "0x140008ef5", + "0x140008e23" + ] + }, + { + "address": "0x140008ef5", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140008ef5", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 1" + }, + { + "address": "0x140008efa", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140008eff", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x140008f04", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x140008f09", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140008f0d", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140008f0f", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140008f11", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140008f12", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140008e23", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008e23", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140008e28", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rax" + }, + { + "address": "0x140008e2b", + "size": 3, + "mnemonic": "add", + "operands": "r9, rbx" + }, + { + "address": "0x140008e2e", + "size": 6, + "mnemonic": "je", + "operands": "0x140008ef5" + } + ], + "successors": [ + "0x140008ef5", + "0x140008e34" + ] + }, + { + "address": "0x140008e34", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008e34", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rsi + 4]" + }, + { + "address": "0x140008e38", + "size": 2, + "mnemonic": "test", + "operands": "ebx, ebx" + }, + { + "address": "0x140008e3a", + "size": 2, + "mnemonic": "je", + "operands": "0x140008e47" + } + ], + "successors": [ + "0x140008e47", + "0x140008e3c" + ] + }, + { + "address": "0x140008e47", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008e47", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140008e4a", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rcx + 0x10], dil" + }, + { + "address": "0x140008e4e", + "size": 6, + "mnemonic": "je", + "operands": "0x140008ef5" + } + ], + "successors": [ + "0x140008ef5", + "0x140008e54" + ] + }, + { + "address": "0x140008e3c", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008e3c", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140008e41", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbx + rax]" + }, + { + "address": "0x140008e45", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140008e4a" + } + ], + "successors": [ + "0x140008e4a" + ] + }, + { + "address": "0x140008e54", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008e54", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [rsi], 0x80" + }, + { + "address": "0x140008e57", + "size": 2, + "mnemonic": "je", + "operands": "0x140008e63" + } + ], + "successors": [ + "0x140008e63", + "0x140008e59" + ] + }, + { + "address": "0x140008e4a", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008e4a", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rcx + 0x10], dil" + }, + { + "address": "0x140008e4e", + "size": 6, + "mnemonic": "je", + "operands": "0x140008ef5" + } + ], + "successors": [ + "0x140008ef5", + "0x140008e54" + ] + }, + { + "address": "0x140008e63", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008e63", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbp, dword ptr [rsi + 4]" + }, + { + "address": "0x140008e67", + "size": 2, + "mnemonic": "test", + "operands": "ebp, ebp" + }, + { + "address": "0x140008e69", + "size": 2, + "mnemonic": "je", + "operands": "0x140008e76" + } + ], + "successors": [ + "0x140008e76", + "0x140008e6b" + ] + }, + { + "address": "0x140008e59", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008e59", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [r14], 0x10" + }, + { + "address": "0x140008e5d", + "size": 6, + "mnemonic": "jne", + "operands": "0x140008ef5" + }, + { + "address": "0x140008e63", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbp, dword ptr [rsi + 4]" + }, + { + "address": "0x140008e67", + "size": 2, + "mnemonic": "test", + "operands": "ebp, ebp" + }, + { + "address": "0x140008e69", + "size": 2, + "mnemonic": "je", + "operands": "0x140008e76" + } + ], + "successors": [ + "0x140008e76", + "0x140008e6b" + ] + }, + { + "address": "0x140008e76", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008e76", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdi" + }, + { + "address": "0x140008e79", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x140008e7e", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [r14 + 4]" + }, + { + "address": "0x140008e82", + "size": 3, + "mnemonic": "add", + "operands": "rcx, rax" + }, + { + "address": "0x140008e85", + "size": 3, + "mnemonic": "cmp", + "operands": "rbx, rcx" + }, + { + "address": "0x140008e88", + "size": 2, + "mnemonic": "je", + "operands": "0x140008ec1" + } + ], + "successors": [ + "0x140008ec1", + "0x140008e8a" + ] + }, + { + "address": "0x140008e6b", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008e6b", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140008e70", + "size": 4, + "mnemonic": "lea", + "operands": "rbx, [rax + rbp]" + }, + { + "address": "0x140008e74", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140008e79" + } + ], + "successors": [ + "0x140008e79" + ] + }, + { + "address": "0x140008ec1", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008ec1", + "size": 2, + "mnemonic": "mov", + "operands": "al, 2" + }, + { + "address": "0x140008ec3", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [r14], al" + }, + { + "address": "0x140008ec6", + "size": 2, + "mnemonic": "je", + "operands": "0x140008ecd" + } + ], + "successors": [ + "0x140008ecd", + "0x140008ec8" + ] + }, + { + "address": "0x140008e8a", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008e8a", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rsi + 4]" + }, + { + "address": "0x140008e8e", + "size": 2, + "mnemonic": "test", + "operands": "ebx, ebx" + }, + { + "address": "0x140008e90", + "size": 2, + "mnemonic": "je", + "operands": "0x140008e9d" + } + ], + "successors": [ + "0x140008e9d", + "0x140008e92" + ] + }, + { + "address": "0x140008e79", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008e79", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x140008e7e", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [r14 + 4]" + }, + { + "address": "0x140008e82", + "size": 3, + "mnemonic": "add", + "operands": "rcx, rax" + }, + { + "address": "0x140008e85", + "size": 3, + "mnemonic": "cmp", + "operands": "rbx, rcx" + }, + { + "address": "0x140008e88", + "size": 2, + "mnemonic": "je", + "operands": "0x140008ec1" + } + ], + "successors": [ + "0x140008ec1", + "0x140008e8a" + ] + }, + { + "address": "0x140008ecd", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008ecd", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [r15], 1" + }, + { + "address": "0x140008ed1", + "size": 2, + "mnemonic": "je", + "operands": "0x140008ed8" + } + ], + "successors": [ + "0x140008ed8", + "0x140008ed3" + ] + }, + { + "address": "0x140008ec8", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008ec8", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [rsi], 8" + }, + { + "address": "0x140008ecb", + "size": 2, + "mnemonic": "je", + "operands": "0x140008ef1" + } + ], + "successors": [ + "0x140008ef1", + "0x140008ecd" + ] + }, + { + "address": "0x140008e9d", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008e9d", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdi" + }, + { + "address": "0x140008ea0", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [r14 + 4]" + }, + { + "address": "0x140008ea4", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x140008ea9", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbx + 0x10]" + }, + { + "address": "0x140008ead", + "size": 3, + "mnemonic": "add", + "operands": "rdx, rax" + }, + { + "address": "0x140008eb0", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x10]" + }, + { + "address": "0x140008eb4", + "size": 5, + "mnemonic": "call", + "operands": "0x14001efd0" + }, + { + "address": "0x140008eb9", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140008ebb", + "size": 2, + "mnemonic": "je", + "operands": "0x140008ec1" + } + ], + "successors": [ + "0x140008ec1", + "0x140008ebd" + ] + }, + { + "address": "0x140008e92", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008e92", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140008e97", + "size": 4, + "mnemonic": "lea", + "operands": "rbp, [rbx + rax]" + }, + { + "address": "0x140008e9b", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140008ea0" + } + ], + "successors": [ + "0x140008ea0" + ] + }, + { + "address": "0x140008ed8", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008ed8", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [r15], 4" + }, + { + "address": "0x140008edc", + "size": 2, + "mnemonic": "je", + "operands": "0x140008ee3" + } + ], + "successors": [ + "0x140008ee3", + "0x140008ede" + ] + }, + { + "address": "0x140008ed3", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008ed3", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [rsi], 1" + }, + { + "address": "0x140008ed6", + "size": 2, + "mnemonic": "je", + "operands": "0x140008ef1" + } + ], + "successors": [ + "0x140008ef1", + "0x140008ed8" + ] + }, + { + "address": "0x140008ef1", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008ef1", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x140008ef3", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140008efa" + } + ], + "successors": [ + "0x140008efa" + ] + }, + { + "address": "0x140008ebd", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008ebd", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140008ebf", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140008efa" + } + ], + "successors": [ + "0x140008efa" + ] + }, + { + "address": "0x140008ea0", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008ea0", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [r14 + 4]" + }, + { + "address": "0x140008ea4", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x140008ea9", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbx + 0x10]" + }, + { + "address": "0x140008ead", + "size": 3, + "mnemonic": "add", + "operands": "rdx, rax" + }, + { + "address": "0x140008eb0", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x10]" + }, + { + "address": "0x140008eb4", + "size": 5, + "mnemonic": "call", + "operands": "0x14001efd0" + }, + { + "address": "0x140008eb9", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140008ebb", + "size": 2, + "mnemonic": "je", + "operands": "0x140008ec1" + } + ], + "successors": [ + "0x140008ec1", + "0x140008ebd" + ] + }, + { + "address": "0x140008ee3", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008ee3", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [r15], al" + }, + { + "address": "0x140008ee6", + "size": 2, + "mnemonic": "je", + "operands": "0x140008eec" + } + ], + "successors": [ + "0x140008eec", + "0x140008ee8" + ] + }, + { + "address": "0x140008ede", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008ede", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [rsi], 4" + }, + { + "address": "0x140008ee1", + "size": 2, + "mnemonic": "je", + "operands": "0x140008ef1" + } + ], + "successors": [ + "0x140008ef1", + "0x140008ee3" + ] + }, + { + "address": "0x140008efa", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140008efa", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140008eff", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x140008f04", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x140008f09", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140008f0d", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140008f0f", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140008f11", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140008f12", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140008eec", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008eec", + "size": 5, + "mnemonic": "mov", + "operands": "edi, 1" + }, + { + "address": "0x140008ef1", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x140008ef3", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140008efa" + } + ], + "successors": [ + "0x140008efa" + ] + }, + { + "address": "0x140008ee8", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008ee8", + "size": 2, + "mnemonic": "test", + "operands": "byte ptr [rsi], al" + }, + { + "address": "0x140008eea", + "size": 2, + "mnemonic": "je", + "operands": "0x140008ef1" + } + ], + "successors": [ + "0x140008ef1", + "0x140008eec" + ] + } + ] + }, + { + "address": "0x140010b70", + "name": "", + "blocks": [ + { + "address": "0x140010b70", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010b70", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x140010b74", + "size": 5, + "mnemonic": "call", + "operands": "0x1400118c4" + }, + { + "address": "0x140010b79", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax + 0x18]" + }, + { + "address": "0x140010b7d", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140010b80", + "size": 2, + "mnemonic": "je", + "operands": "0x140010b89" + } + ], + "successors": [ + "0x140010b89", + "0x140010b82" + ] + }, + { + "address": "0x140010b89", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010b89", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140010b8e", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140010b8f", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140010b82", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010b82", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3a0" + }, + { + "address": "0x140010b87", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140010b89" + } + ], + "successors": [ + "0x140010b89" + ] + } + ] + }, + { + "address": "0x140006f98", + "name": "", + "blocks": [ + { + "address": "0x140006f98", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006f98", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140006f9b", + "size": 2, + "mnemonic": "je", + "operands": "0x14000700b" + } + ], + "successors": [ + "0x14000700b", + "0x140006f9d" + ] + }, + { + "address": "0x14000700b", + "size": 1, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000700b", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140006f9d", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006f9d", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x10], dl" + }, + { + "address": "0x140006fa1", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x48" + }, + { + "address": "0x140006fa5", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rcx], 0xe06d7363" + }, + { + "address": "0x140006fab", + "size": 2, + "mnemonic": "jne", + "operands": "0x140007007" + }, + { + "address": "0x140006fad", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rcx + 0x18], 4" + }, + { + "address": "0x140006fb1", + "size": 2, + "mnemonic": "jne", + "operands": "0x140007007" + }, + { + "address": "0x140006fb3", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rcx + 0x20]" + }, + { + "address": "0x140006fb6", + "size": 5, + "mnemonic": "cmp", + "operands": "eax, 0x19930520" + }, + { + "address": "0x140006fbb", + "size": 2, + "mnemonic": "je", + "operands": "0x140006fc7" + } + ], + "successors": [ + "0x140006fc7", + "0x140006fbd" + ] + }, + { + "address": "0x140006fc7", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006fc7", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0x30]" + }, + { + "address": "0x140006fcb", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140006fce", + "size": 2, + "mnemonic": "je", + "operands": "0x140007007" + } + ], + "successors": [ + "0x140007007", + "0x140006fd0" + ] + }, + { + "address": "0x140006fbd", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006fbd", + "size": 5, + "mnemonic": "add", + "operands": "eax, 0xe66cfadf" + }, + { + "address": "0x140006fc2", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x140006fc5", + "size": 2, + "mnemonic": "ja", + "operands": "0x140007007" + } + ], + "successors": [ + "0x140007007", + "0x140006fc7" + ] + }, + { + "address": "0x140007007", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140007007", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x48" + }, + { + "address": "0x14000700b", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140006fd0", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006fd0", + "size": 4, + "mnemonic": "movsxd", + "operands": "rdx, dword ptr [rax + 4]" + }, + { + "address": "0x140006fd4", + "size": 2, + "mnemonic": "test", + "operands": "edx, edx" + }, + { + "address": "0x140006fd6", + "size": 2, + "mnemonic": "je", + "operands": "0x140006fe9" + } + ], + "successors": [ + "0x140006fe9", + "0x140006fd8" + ] + }, + { + "address": "0x140006fe9", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006fe9", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [rax], 0x10" + }, + { + "address": "0x140006fec", + "size": 2, + "mnemonic": "je", + "operands": "0x140007007" + } + ], + "successors": [ + "0x140007007", + "0x140006fee" + ] + }, + { + "address": "0x140006fd8", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006fd8", + "size": 4, + "mnemonic": "add", + "operands": "rdx, qword ptr [rcx + 0x38]" + }, + { + "address": "0x140006fdc", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x28]" + }, + { + "address": "0x140006fe0", + "size": 5, + "mnemonic": "call", + "operands": "0x14000700c" + }, + { + "address": "0x140006fe5", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140007007" + } + ], + "successors": [ + "0x140007007" + ] + }, + { + "address": "0x140006fee", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006fee", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0x28]" + }, + { + "address": "0x140006ff2", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax]" + }, + { + "address": "0x140006ff5", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140006ff8", + "size": 2, + "mnemonic": "je", + "operands": "0x140007007" + } + ], + "successors": [ + "0x140007007", + "0x140006ffa" + ] + }, + { + "address": "0x140006ffa", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140006ffa", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x140006ffd", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax + 0x10]" + }, + { + "address": "0x140007001", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x192b9]" + }, + { + "address": "0x140007007", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x48" + }, + { + "address": "0x14000700b", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140009724", + "name": "", + "blocks": [ + { + "address": "0x140009724", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140009724", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1a7dd]" + }, + { + "address": "0x14000972b", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 0x10], 0" + }, + { + "address": "0x140009733", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 8], rax" + }, + { + "address": "0x140009737", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1a7ba]" + }, + { + "address": "0x14000973e", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rcx], rax" + }, + { + "address": "0x140009741", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rcx" + }, + { + "address": "0x140009744", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140006198", + "name": "", + "blocks": [ + { + "address": "0x140006198", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006198", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rbx" + }, + { + "address": "0x14000619d", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rsi" + }, + { + "address": "0x1400061a2", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x1400061a3", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x50" + }, + { + "address": "0x1400061a7", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdx" + }, + { + "address": "0x1400061aa", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rcx" + }, + { + "address": "0x1400061ad", + "size": 5, + "mnemonic": "mov", + "operands": "edi, 0x19930520" + }, + { + "address": "0x1400061b2", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x1400061b5", + "size": 2, + "mnemonic": "je", + "operands": "0x1400061d4" + } + ], + "successors": [ + "0x1400061d4", + "0x1400061b7" + ] + }, + { + "address": "0x1400061d4", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400061d4", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x1400061d6", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x1400061db", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x1400061de", + "size": 2, + "mnemonic": "je", + "operands": "0x140006202" + } + ], + "successors": [ + "0x140006202", + "0x1400061e0" + ] + }, + { + "address": "0x1400061b7", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400061b7", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [rdx], 0x10" + }, + { + "address": "0x1400061ba", + "size": 2, + "mnemonic": "je", + "operands": "0x1400061d4" + } + ], + "successors": [ + "0x1400061d4", + "0x1400061bc" + ] + }, + { + "address": "0x140006202", + "size": 14, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140006202", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 1" + }, + { + "address": "0x140006207", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rdi" + }, + { + "address": "0x14000620c", + "size": 5, + "mnemonic": "lea", + "operands": "r9, [rsp + 0x28]" + }, + { + "address": "0x140006211", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rsi" + }, + { + "address": "0x140006216", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0xe06d7363" + }, + { + "address": "0x14000621b", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], rbx" + }, + { + "address": "0x140006220", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x40], rax" + }, + { + "address": "0x140006225", + "size": 4, + "mnemonic": "lea", + "operands": "r8d, [rdx + 3]" + }, + { + "address": "0x140006229", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x19eb9]" + }, + { + "address": "0x14000622f", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140006234", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x78]" + }, + { + "address": "0x140006239", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x50" + }, + { + "address": "0x14000623d", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000623e", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400061e0", + "size": 23, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400061e0", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x20]" + }, + { + "address": "0x1400061e5", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x1400061e8", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x19ef2]" + }, + { + "address": "0x1400061ee", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x1400061f3", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [rbx], 8" + }, + { + "address": "0x1400061f6", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400061fd" + }, + { + "address": "0x1400061f8", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x1400061fb", + "size": 2, + "mnemonic": "jne", + "operands": "0x140006202" + }, + { + "address": "0x1400061fd", + "size": 5, + "mnemonic": "mov", + "operands": "edi, 0x1994000" + }, + { + "address": "0x140006202", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 1" + }, + { + "address": "0x140006207", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rdi" + }, + { + "address": "0x14000620c", + "size": 5, + "mnemonic": "lea", + "operands": "r9, [rsp + 0x28]" + }, + { + "address": "0x140006211", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rsi" + }, + { + "address": "0x140006216", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0xe06d7363" + }, + { + "address": "0x14000621b", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], rbx" + }, + { + "address": "0x140006220", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x40], rax" + }, + { + "address": "0x140006225", + "size": 4, + "mnemonic": "lea", + "operands": "r8d, [rdx + 3]" + }, + { + "address": "0x140006229", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x19eb9]" + }, + { + "address": "0x14000622f", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140006234", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x78]" + }, + { + "address": "0x140006239", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x50" + }, + { + "address": "0x14000623d", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000623e", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400061bc", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400061bc", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx]" + }, + { + "address": "0x1400061bf", + "size": 4, + "mnemonic": "add", + "operands": "rcx, -8" + }, + { + "address": "0x1400061c3", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x1400061c6", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rax + 0x30]" + }, + { + "address": "0x1400061ca", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax + 0x40]" + }, + { + "address": "0x1400061ce", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a0ec]" + }, + { + "address": "0x1400061d4", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x1400061d6", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x1400061db", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x1400061de", + "size": 2, + "mnemonic": "je", + "operands": "0x140006202" + } + ], + "successors": [ + "0x140006202", + "0x1400061e0" + ] + } + ] + }, + { + "address": "0x140006478", + "name": "", + "blocks": [ + { + "address": "0x140006478", + "size": 14, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140006478", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x14000647a", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000647e", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdx" + }, + { + "address": "0x140006481", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rcx" + }, + { + "address": "0x140006484", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140006487", + "size": 5, + "mnemonic": "call", + "operands": "0x1400075d8" + }, + { + "address": "0x14000648c", + "size": 2, + "mnemonic": "mov", + "operands": "edx, eax" + }, + { + "address": "0x14000648e", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140006491", + "size": 5, + "mnemonic": "call", + "operands": "0x1400062e8" + }, + { + "address": "0x140006496", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140006499", + "size": 3, + "mnemonic": "setne", + "operands": "al" + }, + { + "address": "0x14000649c", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400064a0", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x1400064a1", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400075e0", + "name": "", + "blocks": [ + { + "address": "0x1400075e0", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400075e0", + "size": 3, + "mnemonic": "mov", + "operands": "r8, qword ptr [rdx]" + }, + { + "address": "0x1400075e3", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140007650" + } + ], + "successors": [ + "0x140007650" + ] + }, + { + "address": "0x140007650", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007650", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsp" + }, + { + "address": "0x140007653", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 8], rbx" + }, + { + "address": "0x140007657", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x10], rbp" + }, + { + "address": "0x14000765b", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x18], rsi" + }, + { + "address": "0x14000765f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x20], rdi" + }, + { + "address": "0x140007663", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140007665", + "size": 3, + "mnemonic": "or", + "operands": "ebp, 0xffffffff" + }, + { + "address": "0x140007668", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r8" + }, + { + "address": "0x14000766b", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rcx + 0x10], 0" + }, + { + "address": "0x14000766f", + "size": 3, + "mnemonic": "mov", + "operands": "r10, rdx" + }, + { + "address": "0x140007672", + "size": 6, + "mnemonic": "je", + "operands": "0x140007724" + } + ], + "successors": [ + "0x140007724", + "0x140007678" + ] + }, + { + "address": "0x140007724", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140007724", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ebp" + }, + { + "address": "0x140007726", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x10]" + }, + { + "address": "0x14000772b", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x18]" + }, + { + "address": "0x140007730", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x20]" + }, + { + "address": "0x140007735", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x28]" + }, + { + "address": "0x14000773a", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000773c", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140007678", + "size": 16, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007678", + "size": 4, + "mnemonic": "movsxd", + "operands": "r9, dword ptr [rcx + 0x10]" + }, + { + "address": "0x14000767c", + "size": 7, + "mnemonic": "lea", + "operands": "r14, [rip - 0x7683]" + }, + { + "address": "0x140007683", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rdx + 8]" + }, + { + "address": "0x140007687", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x140007689", + "size": 3, + "mnemonic": "add", + "operands": "r9, rsi" + }, + { + "address": "0x14000768c", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x14000768f", + "size": 2, + "mnemonic": "mov", + "operands": "edx, ebp" + }, + { + "address": "0x140007691", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [r9]" + }, + { + "address": "0x140007695", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140007698", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r14 + 0x23d90]" + }, + { + "address": "0x1400076a1", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r14 + 0x23da0]" + }, + { + "address": "0x1400076a9", + "size": 3, + "mnemonic": "sub", + "operands": "r9, rax" + }, + { + "address": "0x1400076ac", + "size": 4, + "mnemonic": "mov", + "operands": "r11d, dword ptr [r9 - 4]" + }, + { + "address": "0x1400076b0", + "size": 3, + "mnemonic": "shr", + "operands": "r11d, cl" + }, + { + "address": "0x1400076b3", + "size": 3, + "mnemonic": "test", + "operands": "r11d, r11d" + }, + { + "address": "0x1400076b6", + "size": 2, + "mnemonic": "je", + "operands": "0x140007724" + } + ], + "successors": [ + "0x140007724", + "0x1400076b8" + ] + }, + { + "address": "0x1400076b8", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400076b8", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [r10 + 0x10]" + }, + { + "address": "0x1400076bc", + "size": 3, + "mnemonic": "mov", + "operands": "r10d, dword ptr [rax]" + }, + { + "address": "0x1400076bf", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [r9]" + }, + { + "address": "0x1400076c3", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x1400076c6", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r14 + 0x23d90]" + }, + { + "address": "0x1400076cf", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r14 + 0x23da0]" + }, + { + "address": "0x1400076d7", + "size": 3, + "mnemonic": "sub", + "operands": "r9, rax" + }, + { + "address": "0x1400076da", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r9 - 4]" + }, + { + "address": "0x1400076de", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x1400076e0", + "size": 2, + "mnemonic": "add", + "operands": "edi, eax" + }, + { + "address": "0x1400076e2", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x1400076e4", + "size": 3, + "mnemonic": "add", + "operands": "rax, r10" + }, + { + "address": "0x1400076e7", + "size": 3, + "mnemonic": "add", + "operands": "rax, rsi" + }, + { + "address": "0x1400076ea", + "size": 3, + "mnemonic": "cmp", + "operands": "rbx, rax" + }, + { + "address": "0x1400076ed", + "size": 2, + "mnemonic": "jb", + "operands": "0x14000771a" + } + ], + "successors": [ + "0x14000771a", + "0x1400076ef" + ] + }, + { + "address": "0x14000771a", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000771a", + "size": 3, + "mnemonic": "test", + "operands": "r8d, r8d" + }, + { + "address": "0x14000771d", + "size": 3, + "mnemonic": "cmove", + "operands": "edx, ebp" + }, + { + "address": "0x140007720", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edx" + }, + { + "address": "0x140007722", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140007726" + } + ], + "successors": [ + "0x140007726" + ] + }, + { + "address": "0x1400076ef", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400076ef", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [r9]" + }, + { + "address": "0x1400076f3", + "size": 3, + "mnemonic": "inc", + "operands": "r8d" + }, + { + "address": "0x1400076f6", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x1400076f9", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r14 + 0x23d90]" + }, + { + "address": "0x140007702", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r14 + 0x23da0]" + }, + { + "address": "0x14000770a", + "size": 3, + "mnemonic": "sub", + "operands": "r9, rax" + }, + { + "address": "0x14000770d", + "size": 4, + "mnemonic": "mov", + "operands": "edx, dword ptr [r9 - 4]" + }, + { + "address": "0x140007711", + "size": 2, + "mnemonic": "shr", + "operands": "edx, cl" + }, + { + "address": "0x140007713", + "size": 2, + "mnemonic": "dec", + "operands": "edx" + }, + { + "address": "0x140007715", + "size": 3, + "mnemonic": "cmp", + "operands": "r8d, r11d" + }, + { + "address": "0x140007718", + "size": 2, + "mnemonic": "jb", + "operands": "0x1400076bf" + } + ], + "successors": [ + "0x1400076bf", + "0x14000771a" + ] + }, + { + "address": "0x140007726", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140007726", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x10]" + }, + { + "address": "0x14000772b", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x18]" + }, + { + "address": "0x140007730", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x20]" + }, + { + "address": "0x140007735", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x28]" + }, + { + "address": "0x14000773a", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000773c", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400076bf", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400076bf", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [r9]" + }, + { + "address": "0x1400076c3", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x1400076c6", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r14 + 0x23d90]" + }, + { + "address": "0x1400076cf", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r14 + 0x23da0]" + }, + { + "address": "0x1400076d7", + "size": 3, + "mnemonic": "sub", + "operands": "r9, rax" + }, + { + "address": "0x1400076da", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r9 - 4]" + }, + { + "address": "0x1400076de", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x1400076e0", + "size": 2, + "mnemonic": "add", + "operands": "edi, eax" + }, + { + "address": "0x1400076e2", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x1400076e4", + "size": 3, + "mnemonic": "add", + "operands": "rax, r10" + }, + { + "address": "0x1400076e7", + "size": 3, + "mnemonic": "add", + "operands": "rax, rsi" + }, + { + "address": "0x1400076ea", + "size": 3, + "mnemonic": "cmp", + "operands": "rbx, rax" + }, + { + "address": "0x1400076ed", + "size": 2, + "mnemonic": "jb", + "operands": "0x14000771a" + } + ], + "successors": [ + "0x14000771a", + "0x1400076ef" + ] + } + ] + }, + { + "address": "0x140009604", + "name": "", + "blocks": [ + { + "address": "0x140009604", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009604", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140009606", + "size": 3, + "mnemonic": "xorps", + "operands": "xmm0, xmm0" + }, + { + "address": "0x140009609", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 8], rax" + }, + { + "address": "0x14000960d", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rcx" + }, + { + "address": "0x140009610", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 0x10], rax" + }, + { + "address": "0x140009614", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx + 0x18], xmm0" + }, + { + "address": "0x140009618", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rdx + 0xc], eax" + }, + { + "address": "0x14000961b", + "size": 6, + "mnemonic": "je", + "operands": "0x1400096e2" + } + ], + "successors": [ + "0x1400096e2", + "0x140009621" + ] + }, + { + "address": "0x1400096e2", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400096e2", + "size": 2, + "mnemonic": "mov", + "operands": "dword ptr [rcx], eax" + }, + { + "address": "0x1400096e4", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r9" + }, + { + "address": "0x1400096e7", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140009621", + "size": 46, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009621", + "size": 4, + "mnemonic": "movsxd", + "operands": "rdx, dword ptr [rdx + 0xc]" + }, + { + "address": "0x140009625", + "size": 3, + "mnemonic": "add", + "operands": "rdx, r8" + }, + { + "address": "0x140009628", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip - 0x962f]" + }, + { + "address": "0x14000962f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 8], rdx" + }, + { + "address": "0x140009633", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140009636", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140009639", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r8 + 0x23d90]" + }, + { + "address": "0x140009642", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r8 + 0x23da0]" + }, + { + "address": "0x14000964a", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, rax" + }, + { + "address": "0x14000964d", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x140009650", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140009652", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r9 + 8], rdx" + }, + { + "address": "0x140009656", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [r9], eax" + }, + { + "address": "0x140009659", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r9 + 0x10], rdx" + }, + { + "address": "0x14000965d", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140009660", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140009663", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r8 + 0x23d90]" + }, + { + "address": "0x14000966c", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r8 + 0x23da0]" + }, + { + "address": "0x140009674", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, rax" + }, + { + "address": "0x140009677", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x14000967a", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x14000967c", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r9 + 8], rdx" + }, + { + "address": "0x140009680", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r9 + 0x18], eax" + }, + { + "address": "0x140009684", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140009687", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x14000968a", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r8 + 0x23d90]" + }, + { + "address": "0x140009693", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r8 + 0x23da0]" + }, + { + "address": "0x14000969b", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, rax" + }, + { + "address": "0x14000969e", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x1400096a1", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x1400096a3", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r9 + 8], rdx" + }, + { + "address": "0x1400096a7", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r9 + 0x1c], eax" + }, + { + "address": "0x1400096ab", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x1400096ae", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x1400096b1", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r8 + 0x23d90]" + }, + { + "address": "0x1400096ba", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r8 + 0x23da0]" + }, + { + "address": "0x1400096c2", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, rax" + }, + { + "address": "0x1400096c5", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x1400096c8", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x1400096ca", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r9 + 0x20], eax" + }, + { + "address": "0x1400096ce", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rdx + 4]" + }, + { + "address": "0x1400096d2", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r9 + 8], rdx" + }, + { + "address": "0x1400096d6", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rdx]" + }, + { + "address": "0x1400096d8", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r9 + 8], rax" + }, + { + "address": "0x1400096dc", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r9 + 0x24], ecx" + }, + { + "address": "0x1400096e0", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400096e4" + } + ], + "successors": [ + "0x1400096e4" + ] + }, + { + "address": "0x1400096e4", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400096e4", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r9" + }, + { + "address": "0x1400096e7", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140006788", + "name": "", + "blocks": [ + { + "address": "0x140006788", + "size": 27, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006788", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsp" + }, + { + "address": "0x14000678b", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 8], rbx" + }, + { + "address": "0x14000678f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x10], rbp" + }, + { + "address": "0x140006793", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x18], rsi" + }, + { + "address": "0x140006797", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x20], rdi" + }, + { + "address": "0x14000679b", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x14000679d", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000679f", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x1400067a1", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x1400067a5", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rdx" + }, + { + "address": "0x1400067aa", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdx" + }, + { + "address": "0x1400067ad", + "size": 4, + "mnemonic": "movaps", + "operands": "xmmword ptr [rax - 0x28], xmm6" + }, + { + "address": "0x1400067b1", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rcx" + }, + { + "address": "0x1400067b4", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rdx" + }, + { + "address": "0x1400067b9", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x1400067bb", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], edi" + }, + { + "address": "0x1400067bf", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rax - 0x38]" + }, + { + "address": "0x1400067c3", + "size": 5, + "mnemonic": "movaps", + "operands": "xmm6, xmmword ptr [rsp + 0x20]" + }, + { + "address": "0x1400067c8", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x1400067cb", + "size": 5, + "mnemonic": "movdqa", + "operands": "xmmword ptr [rax - 0x38], xmm6" + }, + { + "address": "0x1400067d0", + "size": 3, + "mnemonic": "mov", + "operands": "r14d, r8d" + }, + { + "address": "0x1400067d3", + "size": 2, + "mnemonic": "xor", + "operands": "esi, esi" + }, + { + "address": "0x1400067d5", + "size": 5, + "mnemonic": "call", + "operands": "0x140006b2c" + }, + { + "address": "0x1400067da", + "size": 3, + "mnemonic": "mov", + "operands": "r15d, dword ptr [rbx]" + }, + { + "address": "0x1400067dd", + "size": 3, + "mnemonic": "xor", + "operands": "r10d, r10d" + }, + { + "address": "0x1400067e0", + "size": 3, + "mnemonic": "test", + "operands": "r15d, r15d" + }, + { + "address": "0x1400067e3", + "size": 6, + "mnemonic": "je", + "operands": "0x1400068b9" + } + ], + "successors": [ + "0x1400068b9", + "0x1400067e9" + ] + }, + { + "address": "0x1400068b9", + "size": 21, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400068b9", + "size": 2, + "mnemonic": "inc", + "operands": "esi" + }, + { + "address": "0x1400068bb", + "size": 6, + "mnemonic": "movdqa", + "operands": "xmmword ptr [rsp + 0x40], xmm6" + }, + { + "address": "0x1400068c1", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x40]" + }, + { + "address": "0x1400068c6", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x38], esi" + }, + { + "address": "0x1400068ca", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x1400068cd", + "size": 5, + "mnemonic": "call", + "operands": "0x140006b2c" + }, + { + "address": "0x1400068d2", + "size": 5, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rsp + 0x30]" + }, + { + "address": "0x1400068d7", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x60]" + }, + { + "address": "0x1400068dc", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbp" + }, + { + "address": "0x1400068df", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x20]" + }, + { + "address": "0x1400068e3", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x30]" + }, + { + "address": "0x1400068e7", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x38]" + }, + { + "address": "0x1400068eb", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp], xmm6" + }, + { + "address": "0x1400068f0", + "size": 5, + "mnemonic": "movaps", + "operands": "xmm6, xmmword ptr [rsp + 0x50]" + }, + { + "address": "0x1400068f5", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp + 0x10], xmm0" + }, + { + "address": "0x1400068fa", + "size": 4, + "mnemonic": "mov", + "operands": "rbp, qword ptr [r11 + 0x28]" + }, + { + "address": "0x1400068fe", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x140006901", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140006903", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140006905", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140006907", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400067e9", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400067e9", + "size": 4, + "mnemonic": "mov", + "operands": "r11, qword ptr [rbx + 8]" + }, + { + "address": "0x1400067ed", + "size": 7, + "mnemonic": "lea", + "operands": "r12, [rip - 0x67f4]" + }, + { + "address": "0x1400067f4", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx + 0x18]" + }, + { + "address": "0x1400067f8", + "size": 3, + "mnemonic": "cmp", + "operands": "r14d, eax" + }, + { + "address": "0x1400067fb", + "size": 2, + "mnemonic": "jl", + "operands": "0x14000681c" + } + ], + "successors": [ + "0x14000681c", + "0x1400067fd" + ] + }, + { + "address": "0x14000681c", + "size": 60, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000681c", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [r11]" + }, + { + "address": "0x140006820", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r11" + }, + { + "address": "0x140006823", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140006826", + "size": 3, + "mnemonic": "inc", + "operands": "r10d" + }, + { + "address": "0x140006829", + "size": 9, + "mnemonic": "movsx", + "operands": "r9, byte ptr [rcx + r12 + 0x23d90]" + }, + { + "address": "0x140006832", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r12 + 0x23da0]" + }, + { + "address": "0x14000683a", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x14000683d", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x140006840", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], rdx" + }, + { + "address": "0x140006844", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140006846", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 0x18], eax" + }, + { + "address": "0x140006849", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x14000684c", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r11" + }, + { + "address": "0x14000684f", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140006852", + "size": 9, + "mnemonic": "movsx", + "operands": "r8, byte ptr [rcx + r12 + 0x23d90]" + }, + { + "address": "0x14000685b", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r12 + 0x23da0]" + }, + { + "address": "0x140006863", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r8" + }, + { + "address": "0x140006866", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x140006869", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x14000686c", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x14000686e", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], rdx" + }, + { + "address": "0x140006872", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 0x1c], eax" + }, + { + "address": "0x140006875", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140006878", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x14000687b", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r12 + 0x23d90]" + }, + { + "address": "0x140006884", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r12 + 0x23da0]" + }, + { + "address": "0x14000688c", + "size": 3, + "mnemonic": "sub", + "operands": "r11, rax" + }, + { + "address": "0x14000688f", + "size": 3, + "mnemonic": "sub", + "operands": "r11, r8" + }, + { + "address": "0x140006892", + "size": 3, + "mnemonic": "sub", + "operands": "r11, r9" + }, + { + "address": "0x140006895", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r11 - 4]" + }, + { + "address": "0x140006899", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x14000689b", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], r11" + }, + { + "address": "0x14000689f", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 0x20], eax" + }, + { + "address": "0x1400068a2", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [r11]" + }, + { + "address": "0x1400068a5", + "size": 4, + "mnemonic": "add", + "operands": "r11, 4" + }, + { + "address": "0x1400068a9", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], r11" + }, + { + "address": "0x1400068ad", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 0x24], eax" + }, + { + "address": "0x1400068b0", + "size": 3, + "mnemonic": "cmp", + "operands": "r10d, r15d" + }, + { + "address": "0x1400068b3", + "size": 6, + "mnemonic": "jne", + "operands": "0x1400067f4" + }, + { + "address": "0x1400068b9", + "size": 2, + "mnemonic": "inc", + "operands": "esi" + }, + { + "address": "0x1400068bb", + "size": 6, + "mnemonic": "movdqa", + "operands": "xmmword ptr [rsp + 0x40], xmm6" + }, + { + "address": "0x1400068c1", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x40]" + }, + { + "address": "0x1400068c6", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x38], esi" + }, + { + "address": "0x1400068ca", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x1400068cd", + "size": 5, + "mnemonic": "call", + "operands": "0x140006b2c" + }, + { + "address": "0x1400068d2", + "size": 5, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rsp + 0x30]" + }, + { + "address": "0x1400068d7", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x60]" + }, + { + "address": "0x1400068dc", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbp" + }, + { + "address": "0x1400068df", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x20]" + }, + { + "address": "0x1400068e3", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x30]" + }, + { + "address": "0x1400068e7", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x38]" + }, + { + "address": "0x1400068eb", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp], xmm6" + }, + { + "address": "0x1400068f0", + "size": 5, + "mnemonic": "movaps", + "operands": "xmm6, xmmword ptr [rsp + 0x50]" + }, + { + "address": "0x1400068f5", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp + 0x10], xmm0" + }, + { + "address": "0x1400068fa", + "size": 4, + "mnemonic": "mov", + "operands": "rbp, qword ptr [r11 + 0x28]" + }, + { + "address": "0x1400068fe", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x140006901", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140006903", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140006905", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140006907", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400067fd", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400067fd", + "size": 4, + "mnemonic": "shr", + "operands": "rax, 0x20" + }, + { + "address": "0x140006801", + "size": 3, + "mnemonic": "cmp", + "operands": "r14d, eax" + }, + { + "address": "0x140006804", + "size": 2, + "mnemonic": "jg", + "operands": "0x14000681c" + } + ], + "successors": [ + "0x14000681c", + "0x140006806" + ] + }, + { + "address": "0x140006806", + "size": 67, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140006806", + "size": 2, + "mnemonic": "test", + "operands": "edi, edi" + }, + { + "address": "0x140006808", + "size": 3, + "mnemonic": "mov", + "operands": "eax, r10d" + }, + { + "address": "0x14000680b", + "size": 3, + "mnemonic": "mov", + "operands": "esi, r10d" + }, + { + "address": "0x14000680e", + "size": 3, + "mnemonic": "cmove", + "operands": "eax, edi" + }, + { + "address": "0x140006811", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], eax" + }, + { + "address": "0x140006815", + "size": 2, + "mnemonic": "mov", + "operands": "edi, eax" + }, + { + "address": "0x140006817", + "size": 5, + "mnemonic": "movaps", + "operands": "xmm6, xmmword ptr [rsp + 0x20]" + }, + { + "address": "0x14000681c", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [r11]" + }, + { + "address": "0x140006820", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r11" + }, + { + "address": "0x140006823", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140006826", + "size": 3, + "mnemonic": "inc", + "operands": "r10d" + }, + { + "address": "0x140006829", + "size": 9, + "mnemonic": "movsx", + "operands": "r9, byte ptr [rcx + r12 + 0x23d90]" + }, + { + "address": "0x140006832", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r12 + 0x23da0]" + }, + { + "address": "0x14000683a", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x14000683d", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x140006840", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], rdx" + }, + { + "address": "0x140006844", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140006846", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 0x18], eax" + }, + { + "address": "0x140006849", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x14000684c", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r11" + }, + { + "address": "0x14000684f", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140006852", + "size": 9, + "mnemonic": "movsx", + "operands": "r8, byte ptr [rcx + r12 + 0x23d90]" + }, + { + "address": "0x14000685b", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r12 + 0x23da0]" + }, + { + "address": "0x140006863", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r8" + }, + { + "address": "0x140006866", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x140006869", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x14000686c", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x14000686e", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], rdx" + }, + { + "address": "0x140006872", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 0x1c], eax" + }, + { + "address": "0x140006875", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140006878", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x14000687b", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r12 + 0x23d90]" + }, + { + "address": "0x140006884", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r12 + 0x23da0]" + }, + { + "address": "0x14000688c", + "size": 3, + "mnemonic": "sub", + "operands": "r11, rax" + }, + { + "address": "0x14000688f", + "size": 3, + "mnemonic": "sub", + "operands": "r11, r8" + }, + { + "address": "0x140006892", + "size": 3, + "mnemonic": "sub", + "operands": "r11, r9" + }, + { + "address": "0x140006895", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r11 - 4]" + }, + { + "address": "0x140006899", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x14000689b", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], r11" + }, + { + "address": "0x14000689f", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 0x20], eax" + }, + { + "address": "0x1400068a2", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [r11]" + }, + { + "address": "0x1400068a5", + "size": 4, + "mnemonic": "add", + "operands": "r11, 4" + }, + { + "address": "0x1400068a9", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], r11" + }, + { + "address": "0x1400068ad", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 0x24], eax" + }, + { + "address": "0x1400068b0", + "size": 3, + "mnemonic": "cmp", + "operands": "r10d, r15d" + }, + { + "address": "0x1400068b3", + "size": 6, + "mnemonic": "jne", + "operands": "0x1400067f4" + }, + { + "address": "0x1400068b9", + "size": 2, + "mnemonic": "inc", + "operands": "esi" + }, + { + "address": "0x1400068bb", + "size": 6, + "mnemonic": "movdqa", + "operands": "xmmword ptr [rsp + 0x40], xmm6" + }, + { + "address": "0x1400068c1", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x40]" + }, + { + "address": "0x1400068c6", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x38], esi" + }, + { + "address": "0x1400068ca", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x1400068cd", + "size": 5, + "mnemonic": "call", + "operands": "0x140006b2c" + }, + { + "address": "0x1400068d2", + "size": 5, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rsp + 0x30]" + }, + { + "address": "0x1400068d7", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x60]" + }, + { + "address": "0x1400068dc", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbp" + }, + { + "address": "0x1400068df", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x20]" + }, + { + "address": "0x1400068e3", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x30]" + }, + { + "address": "0x1400068e7", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x38]" + }, + { + "address": "0x1400068eb", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp], xmm6" + }, + { + "address": "0x1400068f0", + "size": 5, + "mnemonic": "movaps", + "operands": "xmm6, xmmword ptr [rsp + 0x50]" + }, + { + "address": "0x1400068f5", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp + 0x10], xmm0" + }, + { + "address": "0x1400068fa", + "size": 4, + "mnemonic": "mov", + "operands": "rbp, qword ptr [r11 + 0x28]" + }, + { + "address": "0x1400068fe", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x140006901", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140006903", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140006905", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140006907", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140009580", + "name": "", + "blocks": [ + { + "address": "0x140009580", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009580", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140009582", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140009586", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140009588", + "size": 3, + "mnemonic": "xorps", + "operands": "xmm0, xmm0" + }, + { + "address": "0x14000958b", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 8], rax" + }, + { + "address": "0x14000958f", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140009592", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 0x10], rax" + }, + { + "address": "0x140009596", + "size": 3, + "mnemonic": "mov", + "operands": "byte ptr [rcx + 0x18], al" + }, + { + "address": "0x140009599", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 0x1c], rax" + }, + { + "address": "0x14000959d", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 0x24], rax" + }, + { + "address": "0x1400095a1", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx + 0x30], xmm0" + }, + { + "address": "0x1400095a5", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 0x40], r8" + }, + { + "address": "0x1400095a9", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rcx + 0x48], r9d" + }, + { + "address": "0x1400095ad", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rdx + 0xc], eax" + }, + { + "address": "0x1400095b0", + "size": 2, + "mnemonic": "je", + "operands": "0x1400095f7" + } + ], + "successors": [ + "0x1400095f7", + "0x1400095b2" + ] + }, + { + "address": "0x1400095f7", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400095f7", + "size": 2, + "mnemonic": "mov", + "operands": "dword ptr [rcx], eax" + }, + { + "address": "0x1400095f9", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x1400095fc", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140009600", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140009601", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400095b2", + "size": 17, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400095b2", + "size": 4, + "mnemonic": "movsxd", + "operands": "rdx, dword ptr [rdx + 0xc]" + }, + { + "address": "0x1400095b6", + "size": 3, + "mnemonic": "add", + "operands": "rdx, r8" + }, + { + "address": "0x1400095b9", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip - 0x95c0]" + }, + { + "address": "0x1400095c0", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 8], rdx" + }, + { + "address": "0x1400095c4", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x1400095c7", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x1400095ca", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r8 + 0x23d90]" + }, + { + "address": "0x1400095d3", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r8 + 0x23da0]" + }, + { + "address": "0x1400095db", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, rax" + }, + { + "address": "0x1400095de", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x1400095e1", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x1400095e3", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x1400095e6", + "size": 2, + "mnemonic": "mov", + "operands": "dword ptr [rbx], eax" + }, + { + "address": "0x1400095e8", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], rdx" + }, + { + "address": "0x1400095ec", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x10], rdx" + }, + { + "address": "0x1400095f0", + "size": 5, + "mnemonic": "call", + "operands": "0x140009b74" + }, + { + "address": "0x1400095f5", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400095f9" + } + ], + "successors": [ + "0x1400095f9" + ] + }, + { + "address": "0x1400095f9", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400095f9", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x1400095fc", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140009600", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140009601", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400064a4", + "name": "", + "blocks": [ + { + "address": "0x1400064a4", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400064a4", + "size": 2, + "mnemonic": "mov", + "operands": "al, byte ptr [rdx]" + }, + { + "address": "0x1400064a6", + "size": 2, + "mnemonic": "and", + "operands": "al, 1" + }, + { + "address": "0x1400064a8", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140008f14", + "name": "", + "blocks": [ + { + "address": "0x140008f14", + "size": 16, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008f14", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsp" + }, + { + "address": "0x140008f17", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 8], rbx" + }, + { + "address": "0x140008f1b", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x10], rbp" + }, + { + "address": "0x140008f1f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x18], rsi" + }, + { + "address": "0x140008f23", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x20], rdi" + }, + { + "address": "0x140008f27", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140008f29", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140008f2b", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140008f2d", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140008f31", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rcx + 8]" + }, + { + "address": "0x140008f35", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x140008f37", + "size": 3, + "mnemonic": "mov", + "operands": "r12, r8" + }, + { + "address": "0x140008f3a", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rdx" + }, + { + "address": "0x140008f3d", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rcx" + }, + { + "address": "0x140008f40", + "size": 2, + "mnemonic": "test", + "operands": "ebx, ebx" + }, + { + "address": "0x140008f42", + "size": 6, + "mnemonic": "je", + "operands": "0x14000902f" + } + ], + "successors": [ + "0x14000902f", + "0x140008f48" + ] + }, + { + "address": "0x14000902f", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000902f", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 1" + }, + { + "address": "0x140009034", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140009039", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14000903e", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x140009043", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x58]" + }, + { + "address": "0x140009048", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000904c", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000904e", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140009050", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140009052", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140008f48", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008f48", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140008f4d", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rax" + }, + { + "address": "0x140008f50", + "size": 3, + "mnemonic": "add", + "operands": "r9, rbx" + }, + { + "address": "0x140008f53", + "size": 6, + "mnemonic": "je", + "operands": "0x14000902f" + } + ], + "successors": [ + "0x14000902f", + "0x140008f59" + ] + }, + { + "address": "0x140008f59", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008f59", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rsi + 8]" + }, + { + "address": "0x140008f5d", + "size": 2, + "mnemonic": "test", + "operands": "ebx, ebx" + }, + { + "address": "0x140008f5f", + "size": 2, + "mnemonic": "je", + "operands": "0x140008f6c" + } + ], + "successors": [ + "0x140008f6c", + "0x140008f61" + ] + }, + { + "address": "0x140008f6c", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008f6c", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140008f6f", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rcx + 0x10], dil" + }, + { + "address": "0x140008f73", + "size": 6, + "mnemonic": "je", + "operands": "0x14000902f" + } + ], + "successors": [ + "0x14000902f", + "0x140008f79" + ] + }, + { + "address": "0x140008f61", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008f61", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140008f66", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbx + rax]" + }, + { + "address": "0x140008f6a", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140008f6f" + } + ], + "successors": [ + "0x140008f6f" + ] + }, + { + "address": "0x140008f79", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008f79", + "size": 4, + "mnemonic": "lea", + "operands": "rbx, [rsi + 4]" + }, + { + "address": "0x140008f7d", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [rbx], 0x80" + }, + { + "address": "0x140008f80", + "size": 2, + "mnemonic": "je", + "operands": "0x140008f8c" + } + ], + "successors": [ + "0x140008f8c", + "0x140008f82" + ] + }, + { + "address": "0x140008f6f", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008f6f", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rcx + 0x10], dil" + }, + { + "address": "0x140008f73", + "size": 6, + "mnemonic": "je", + "operands": "0x14000902f" + } + ], + "successors": [ + "0x14000902f", + "0x140008f79" + ] + }, + { + "address": "0x140008f8c", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008f8c", + "size": 4, + "mnemonic": "movsxd", + "operands": "r14, dword ptr [rsi + 8]" + }, + { + "address": "0x140008f90", + "size": 3, + "mnemonic": "test", + "operands": "r14d, r14d" + }, + { + "address": "0x140008f93", + "size": 2, + "mnemonic": "je", + "operands": "0x140008fa0" + } + ], + "successors": [ + "0x140008fa0", + "0x140008f95" + ] + }, + { + "address": "0x140008f82", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008f82", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [r15], 0x10" + }, + { + "address": "0x140008f86", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000902f" + }, + { + "address": "0x140008f8c", + "size": 4, + "mnemonic": "movsxd", + "operands": "r14, dword ptr [rsi + 8]" + }, + { + "address": "0x140008f90", + "size": 3, + "mnemonic": "test", + "operands": "r14d, r14d" + }, + { + "address": "0x140008f93", + "size": 2, + "mnemonic": "je", + "operands": "0x140008fa0" + } + ], + "successors": [ + "0x140008fa0", + "0x140008f95" + ] + }, + { + "address": "0x140008fa0", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008fa0", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdi" + }, + { + "address": "0x140008fa3", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x140008fa8", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [r15 + 4]" + }, + { + "address": "0x140008fac", + "size": 3, + "mnemonic": "add", + "operands": "rcx, rax" + }, + { + "address": "0x140008faf", + "size": 3, + "mnemonic": "cmp", + "operands": "rbp, rcx" + }, + { + "address": "0x140008fb2", + "size": 2, + "mnemonic": "je", + "operands": "0x140008fef" + } + ], + "successors": [ + "0x140008fef", + "0x140008fb4" + ] + }, + { + "address": "0x140008f95", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008f95", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140008f9a", + "size": 4, + "mnemonic": "lea", + "operands": "rbp, [r14 + rax]" + }, + { + "address": "0x140008f9e", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140008fa3" + } + ], + "successors": [ + "0x140008fa3" + ] + }, + { + "address": "0x140008fef", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008fef", + "size": 2, + "mnemonic": "mov", + "operands": "al, 2" + }, + { + "address": "0x140008ff1", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [r15], al" + }, + { + "address": "0x140008ff4", + "size": 2, + "mnemonic": "je", + "operands": "0x140009001" + } + ], + "successors": [ + "0x140009001", + "0x140008ff6" + ] + }, + { + "address": "0x140008fb4", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008fb4", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rsi + 8]" + }, + { + "address": "0x140008fb8", + "size": 2, + "mnemonic": "test", + "operands": "ebx, ebx" + }, + { + "address": "0x140008fba", + "size": 2, + "mnemonic": "je", + "operands": "0x140008fc7" + } + ], + "successors": [ + "0x140008fc7", + "0x140008fbc" + ] + }, + { + "address": "0x140008fa3", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008fa3", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x140008fa8", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [r15 + 4]" + }, + { + "address": "0x140008fac", + "size": 3, + "mnemonic": "add", + "operands": "rcx, rax" + }, + { + "address": "0x140008faf", + "size": 3, + "mnemonic": "cmp", + "operands": "rbp, rcx" + }, + { + "address": "0x140008fb2", + "size": 2, + "mnemonic": "je", + "operands": "0x140008fef" + } + ], + "successors": [ + "0x140008fef", + "0x140008fb4" + ] + }, + { + "address": "0x140009001", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009001", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rbx" + }, + { + "address": "0x140009004", + "size": 5, + "mnemonic": "test", + "operands": "byte ptr [r12], 1" + }, + { + "address": "0x140009009", + "size": 2, + "mnemonic": "je", + "operands": "0x140009010" + } + ], + "successors": [ + "0x140009010", + "0x14000900b" + ] + }, + { + "address": "0x140008ff6", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008ff6", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [rbx], 8" + }, + { + "address": "0x140008ff9", + "size": 2, + "mnemonic": "je", + "operands": "0x14000902b" + } + ], + "successors": [ + "0x14000902b", + "0x140008ffb" + ] + }, + { + "address": "0x140008fc7", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008fc7", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdi" + }, + { + "address": "0x140008fca", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [r15 + 4]" + }, + { + "address": "0x140008fce", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x140008fd3", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbx + 0x10]" + }, + { + "address": "0x140008fd7", + "size": 3, + "mnemonic": "add", + "operands": "rdx, rax" + }, + { + "address": "0x140008fda", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x10]" + }, + { + "address": "0x140008fde", + "size": 5, + "mnemonic": "call", + "operands": "0x14001efd0" + }, + { + "address": "0x140008fe3", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140008fe5", + "size": 2, + "mnemonic": "je", + "operands": "0x140008feb" + } + ], + "successors": [ + "0x140008feb", + "0x140008fe7" + ] + }, + { + "address": "0x140008fbc", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008fbc", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140008fc1", + "size": 4, + "mnemonic": "lea", + "operands": "rbp, [rbx + rax]" + }, + { + "address": "0x140008fc5", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140008fca" + } + ], + "successors": [ + "0x140008fca" + ] + }, + { + "address": "0x140009010", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009010", + "size": 5, + "mnemonic": "test", + "operands": "byte ptr [r12], 4" + }, + { + "address": "0x140009015", + "size": 2, + "mnemonic": "je", + "operands": "0x14000901c" + } + ], + "successors": [ + "0x14000901c", + "0x140009017" + ] + }, + { + "address": "0x14000900b", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000900b", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [rbx], 1" + }, + { + "address": "0x14000900e", + "size": 2, + "mnemonic": "je", + "operands": "0x14000902b" + } + ], + "successors": [ + "0x14000902b", + "0x140009010" + ] + }, + { + "address": "0x14000902b", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000902b", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x14000902d", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140009034" + } + ], + "successors": [ + "0x140009034" + ] + }, + { + "address": "0x140008ffb", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008ffb", + "size": 4, + "mnemonic": "add", + "operands": "rsi, 4" + }, + { + "address": "0x140008fff", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140009004" + } + ], + "successors": [ + "0x140009004" + ] + }, + { + "address": "0x140008feb", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008feb", + "size": 4, + "mnemonic": "lea", + "operands": "rbx, [rsi + 4]" + }, + { + "address": "0x140008fef", + "size": 2, + "mnemonic": "mov", + "operands": "al, 2" + }, + { + "address": "0x140008ff1", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [r15], al" + }, + { + "address": "0x140008ff4", + "size": 2, + "mnemonic": "je", + "operands": "0x140009001" + } + ], + "successors": [ + "0x140009001", + "0x140008ff6" + ] + }, + { + "address": "0x140008fe7", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008fe7", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140008fe9", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140009034" + } + ], + "successors": [ + "0x140009034" + ] + }, + { + "address": "0x140008fca", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140008fca", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [r15 + 4]" + }, + { + "address": "0x140008fce", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x140008fd3", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbx + 0x10]" + }, + { + "address": "0x140008fd7", + "size": 3, + "mnemonic": "add", + "operands": "rdx, rax" + }, + { + "address": "0x140008fda", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x10]" + }, + { + "address": "0x140008fde", + "size": 5, + "mnemonic": "call", + "operands": "0x14001efd0" + }, + { + "address": "0x140008fe3", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140008fe5", + "size": 2, + "mnemonic": "je", + "operands": "0x140008feb" + } + ], + "successors": [ + "0x140008feb", + "0x140008fe7" + ] + }, + { + "address": "0x14000901c", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000901c", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [r12], al" + }, + { + "address": "0x140009020", + "size": 2, + "mnemonic": "je", + "operands": "0x140009026" + } + ], + "successors": [ + "0x140009026", + "0x140009022" + ] + }, + { + "address": "0x140009017", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009017", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [rbx], 4" + }, + { + "address": "0x14000901a", + "size": 2, + "mnemonic": "je", + "operands": "0x14000902b" + } + ], + "successors": [ + "0x14000902b", + "0x14000901c" + ] + }, + { + "address": "0x140009034", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140009034", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140009039", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14000903e", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x140009043", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x58]" + }, + { + "address": "0x140009048", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000904c", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000904e", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140009050", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140009052", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140009004", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009004", + "size": 5, + "mnemonic": "test", + "operands": "byte ptr [r12], 1" + }, + { + "address": "0x140009009", + "size": 2, + "mnemonic": "je", + "operands": "0x140009010" + } + ], + "successors": [ + "0x140009010", + "0x14000900b" + ] + }, + { + "address": "0x140009026", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009026", + "size": 5, + "mnemonic": "mov", + "operands": "edi, 1" + }, + { + "address": "0x14000902b", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x14000902d", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140009034" + } + ], + "successors": [ + "0x140009034" + ] + }, + { + "address": "0x140009022", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009022", + "size": 2, + "mnemonic": "test", + "operands": "byte ptr [rsi], al" + }, + { + "address": "0x140009024", + "size": 2, + "mnemonic": "je", + "operands": "0x14000902b" + } + ], + "successors": [ + "0x14000902b", + "0x140009026" + ] + } + ] + }, + { + "address": "0x140009b74", + "name": "", + "blocks": [ + { + "address": "0x140009b74", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009b74", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140009b76", + "size": 7, + "mnemonic": "lea", + "operands": "r11, [rip - 0x9b7d]" + }, + { + "address": "0x140009b7d", + "size": 3, + "mnemonic": "mov", + "operands": "byte ptr [rcx + 0x18], al" + }, + { + "address": "0x140009b80", + "size": 3, + "mnemonic": "xorps", + "operands": "xmm0, xmm0" + }, + { + "address": "0x140009b83", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 0x1c], rax" + }, + { + "address": "0x140009b87", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rcx" + }, + { + "address": "0x140009b8a", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 0x24], rax" + }, + { + "address": "0x140009b8e", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rcx + 0x30], xmm0" + }, + { + "address": "0x140009b92", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 8]" + }, + { + "address": "0x140009b96", + "size": 3, + "mnemonic": "mov", + "operands": "r10b, byte ptr [rax]" + }, + { + "address": "0x140009b99", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rax + 1]" + }, + { + "address": "0x140009b9d", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rcx + 0x18], r10b" + }, + { + "address": "0x140009ba1", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 8], rdx" + }, + { + "address": "0x140009ba5", + "size": 4, + "mnemonic": "test", + "operands": "r10b, 1" + }, + { + "address": "0x140009ba9", + "size": 2, + "mnemonic": "je", + "operands": "0x140009bd2" + } + ], + "successors": [ + "0x140009bd2", + "0x140009bab" + ] + }, + { + "address": "0x140009bd2", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009bd2", + "size": 4, + "mnemonic": "test", + "operands": "r10b, 2" + }, + { + "address": "0x140009bd6", + "size": 2, + "mnemonic": "je", + "operands": "0x140009be6" + } + ], + "successors": [ + "0x140009be6", + "0x140009bd8" + ] + }, + { + "address": "0x140009bab", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009bab", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140009bae", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140009bb1", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x140009bba", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140009bc2", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, rax" + }, + { + "address": "0x140009bc5", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x140009bc8", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140009bca", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r8 + 0x1c], eax" + }, + { + "address": "0x140009bce", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r8 + 8], rdx" + }, + { + "address": "0x140009bd2", + "size": 4, + "mnemonic": "test", + "operands": "r10b, 2" + }, + { + "address": "0x140009bd6", + "size": 2, + "mnemonic": "je", + "operands": "0x140009be6" + } + ], + "successors": [ + "0x140009be6", + "0x140009bd8" + ] + }, + { + "address": "0x140009be6", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009be6", + "size": 4, + "mnemonic": "test", + "operands": "r10b, 4" + }, + { + "address": "0x140009bea", + "size": 2, + "mnemonic": "je", + "operands": "0x140009c13" + } + ], + "successors": [ + "0x140009c13", + "0x140009bec" + ] + }, + { + "address": "0x140009bd8", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009bd8", + "size": 2, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx]" + }, + { + "address": "0x140009bda", + "size": 4, + "mnemonic": "add", + "operands": "rdx, 4" + }, + { + "address": "0x140009bde", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r8 + 8], rdx" + }, + { + "address": "0x140009be2", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r8 + 0x20], eax" + }, + { + "address": "0x140009be6", + "size": 4, + "mnemonic": "test", + "operands": "r10b, 4" + }, + { + "address": "0x140009bea", + "size": 2, + "mnemonic": "je", + "operands": "0x140009c13" + } + ], + "successors": [ + "0x140009c13", + "0x140009bec" + ] + }, + { + "address": "0x140009c13", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009c13", + "size": 2, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx]" + }, + { + "address": "0x140009c15", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rdx + 4]" + }, + { + "address": "0x140009c19", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r8 + 0x28], eax" + }, + { + "address": "0x140009c1d", + "size": 3, + "mnemonic": "mov", + "operands": "al, r10b" + }, + { + "address": "0x140009c20", + "size": 2, + "mnemonic": "and", + "operands": "al, 0x30" + }, + { + "address": "0x140009c22", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r8 + 8], r9" + }, + { + "address": "0x140009c26", + "size": 4, + "mnemonic": "test", + "operands": "r10b, 8" + }, + { + "address": "0x140009c2a", + "size": 2, + "mnemonic": "je", + "operands": "0x140009c67" + } + ], + "successors": [ + "0x140009c67", + "0x140009c2c" + ] + }, + { + "address": "0x140009bec", + "size": 17, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009bec", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140009bef", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140009bf2", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x140009bfb", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140009c03", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, rax" + }, + { + "address": "0x140009c06", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x140009c09", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140009c0b", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r8 + 0x24], eax" + }, + { + "address": "0x140009c0f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r8 + 8], rdx" + }, + { + "address": "0x140009c13", + "size": 2, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx]" + }, + { + "address": "0x140009c15", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rdx + 4]" + }, + { + "address": "0x140009c19", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r8 + 0x28], eax" + }, + { + "address": "0x140009c1d", + "size": 3, + "mnemonic": "mov", + "operands": "al, r10b" + }, + { + "address": "0x140009c20", + "size": 2, + "mnemonic": "and", + "operands": "al, 0x30" + }, + { + "address": "0x140009c22", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r8 + 8], r9" + }, + { + "address": "0x140009c26", + "size": 4, + "mnemonic": "test", + "operands": "r10b, 8" + }, + { + "address": "0x140009c2a", + "size": 2, + "mnemonic": "je", + "operands": "0x140009c67" + } + ], + "successors": [ + "0x140009c67", + "0x140009c2c" + ] + }, + { + "address": "0x140009c67", + "size": 14, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140009c67", + "size": 2, + "mnemonic": "cmp", + "operands": "al, 0x10" + }, + { + "address": "0x140009c69", + "size": 2, + "mnemonic": "jne", + "operands": "0x140009c9b" + }, + { + "address": "0x140009c6b", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [r9]" + }, + { + "address": "0x140009c6f", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140009c72", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x140009c7b", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x140009c83", + "size": 3, + "mnemonic": "sub", + "operands": "r9, rax" + }, + { + "address": "0x140009c86", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r8 + 0x48]" + }, + { + "address": "0x140009c8a", + "size": 4, + "mnemonic": "mov", + "operands": "edx, dword ptr [r9 - 4]" + }, + { + "address": "0x140009c8e", + "size": 2, + "mnemonic": "shr", + "operands": "edx, cl" + }, + { + "address": "0x140009c90", + "size": 2, + "mnemonic": "add", + "operands": "eax, edx" + }, + { + "address": "0x140009c92", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r8 + 8], r9" + }, + { + "address": "0x140009c96", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r8 + 0x30], rax" + }, + { + "address": "0x140009c9a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140009c2c", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140009c2c", + "size": 2, + "mnemonic": "cmp", + "operands": "al, 0x10" + }, + { + "address": "0x140009c2e", + "size": 2, + "mnemonic": "jne", + "operands": "0x140009c40" + }, + { + "address": "0x140009c30", + "size": 3, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [r9]" + }, + { + "address": "0x140009c33", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r9 + 4]" + }, + { + "address": "0x140009c37", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r8 + 8], rax" + }, + { + "address": "0x140009c3b", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r8 + 0x30], rcx" + }, + { + "address": "0x140009c3f", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140007cb0", + "name": "", + "blocks": [ + { + "address": "0x140007cb0", + "size": 24, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007cb0", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsp" + }, + { + "address": "0x140007cb3", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 8], rbx" + }, + { + "address": "0x140007cb7", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x18], r8" + }, + { + "address": "0x140007cbb", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140007cbc", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140007cbd", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140007cbe", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140007cc0", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140007cc2", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140007cc4", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140007cc6", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x140007cca", + "size": 8, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsp + 0xc0]" + }, + { + "address": "0x140007cd2", + "size": 3, + "mnemonic": "mov", + "operands": "r12, r9" + }, + { + "address": "0x140007cd5", + "size": 3, + "mnemonic": "mov", + "operands": "r13, rdx" + }, + { + "address": "0x140007cd8", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rax + 0x10]" + }, + { + "address": "0x140007cdc", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rcx" + }, + { + "address": "0x140007cdf", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r12" + }, + { + "address": "0x140007ce2", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r13" + }, + { + "address": "0x140007ce5", + "size": 5, + "mnemonic": "call", + "operands": "0x140006544" + }, + { + "address": "0x140007cea", + "size": 8, + "mnemonic": "mov", + "operands": "r9, qword ptr [rsp + 0xd0]" + }, + { + "address": "0x140007cf2", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rax" + }, + { + "address": "0x140007cf5", + "size": 8, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0xc8]" + }, + { + "address": "0x140007cfd", + "size": 3, + "mnemonic": "test", + "operands": "r9, r9" + }, + { + "address": "0x140007d00", + "size": 2, + "mnemonic": "je", + "operands": "0x140007d10" + } + ], + "successors": [ + "0x140007d10", + "0x140007d02" + ] + } + ] + }, + { + "address": "0x140006240", + "name": "", + "blocks": [ + { + "address": "0x140006240", + "size": 18, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006240", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsp" + }, + { + "address": "0x140006243", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x20], r9" + }, + { + "address": "0x140006247", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x18], r8" + }, + { + "address": "0x14000624b", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x10], rdx" + }, + { + "address": "0x14000624f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 8], rcx" + }, + { + "address": "0x140006253", + "size": 1, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140006254", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x140006258", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14000625b", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rax - 0x28], 0" + }, + { + "address": "0x140006262", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax - 0x18], rcx" + }, + { + "address": "0x140006266", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax - 0x10], r8" + }, + { + "address": "0x14000626a", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14000626f", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x50]" + }, + { + "address": "0x140006274", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbx]" + }, + { + "address": "0x140006276", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax + 0x10]" + }, + { + "address": "0x14000627a", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1a040]" + }, + { + "address": "0x140006280", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x40], 0" + }, + { + "address": "0x140006288", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000628a" + } + ], + "successors": [ + "0x14000628a" + ] + }, + { + "address": "0x14000628a", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000628a", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [rsp + 0x40]" + }, + { + "address": "0x14000628e", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x140006292", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140006293", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140006294", + "name": "", + "blocks": [ + { + "address": "0x140006294", + "size": 18, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006294", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsp" + }, + { + "address": "0x140006297", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x20], r9" + }, + { + "address": "0x14000629b", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x18], r8" + }, + { + "address": "0x14000629f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x10], rdx" + }, + { + "address": "0x1400062a3", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 8], rcx" + }, + { + "address": "0x1400062a7", + "size": 1, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x1400062a8", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x1400062ac", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x1400062af", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rax - 0x28], 0" + }, + { + "address": "0x1400062b6", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax - 0x18], rcx" + }, + { + "address": "0x1400062ba", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax - 0x10], r8" + }, + { + "address": "0x1400062be", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x1400062c3", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x50]" + }, + { + "address": "0x1400062c8", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbx]" + }, + { + "address": "0x1400062ca", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax + 0x10]" + }, + { + "address": "0x1400062ce", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x19fec]" + }, + { + "address": "0x1400062d4", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x40], 0" + }, + { + "address": "0x1400062dc", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400062de" + } + ], + "successors": [ + "0x1400062de" + ] + }, + { + "address": "0x1400062de", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400062de", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [rsp + 0x40]" + }, + { + "address": "0x1400062e2", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x1400062e6", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x1400062e7", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140007d88", + "name": "", + "blocks": [ + { + "address": "0x140007d88", + "size": 24, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007d88", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsp" + }, + { + "address": "0x140007d8b", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 8], rbx" + }, + { + "address": "0x140007d8f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x18], r8" + }, + { + "address": "0x140007d93", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140007d94", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140007d95", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140007d96", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140007d98", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140007d9a", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140007d9c", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140007d9e", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x140007da2", + "size": 8, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsp + 0xc0]" + }, + { + "address": "0x140007daa", + "size": 3, + "mnemonic": "mov", + "operands": "r12, r9" + }, + { + "address": "0x140007dad", + "size": 3, + "mnemonic": "mov", + "operands": "r13, rdx" + }, + { + "address": "0x140007db0", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rax + 0x10]" + }, + { + "address": "0x140007db4", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rcx" + }, + { + "address": "0x140007db7", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r12" + }, + { + "address": "0x140007dba", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r13" + }, + { + "address": "0x140007dbd", + "size": 5, + "mnemonic": "call", + "operands": "0x14000662c" + }, + { + "address": "0x140007dc2", + "size": 8, + "mnemonic": "mov", + "operands": "r9, qword ptr [rsp + 0xd0]" + }, + { + "address": "0x140007dca", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rax" + }, + { + "address": "0x140007dcd", + "size": 8, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0xc8]" + }, + { + "address": "0x140007dd5", + "size": 3, + "mnemonic": "test", + "operands": "r9, r9" + }, + { + "address": "0x140007dd8", + "size": 2, + "mnemonic": "je", + "operands": "0x140007de8" + } + ], + "successors": [ + "0x140007de8", + "0x140007dda" + ] + } + ] + }, + { + "address": "0x14000a464", + "name": "", + "blocks": [ + { + "address": "0x14000a464", + "size": 19, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a464", + "size": 3, + "mnemonic": "mov", + "operands": "r8, qword ptr [rdx]" + }, + { + "address": "0x14000a467", + "size": 7, + "mnemonic": "lea", + "operands": "r11, [rip - 0xa46e]" + }, + { + "address": "0x14000a46e", + "size": 3, + "mnemonic": "mov", + "operands": "r10, rcx" + }, + { + "address": "0x14000a471", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rdx" + }, + { + "address": "0x14000a474", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [r8]" + }, + { + "address": "0x14000a478", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x14000a47b", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x14000a484", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x14000a48c", + "size": 3, + "mnemonic": "sub", + "operands": "r8, rax" + }, + { + "address": "0x14000a48f", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r8 - 4]" + }, + { + "address": "0x14000a493", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x14000a495", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, eax" + }, + { + "address": "0x14000a497", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rdx], r8" + }, + { + "address": "0x14000a49a", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 3" + }, + { + "address": "0x14000a49d", + "size": 3, + "mnemonic": "shr", + "operands": "eax, 2" + }, + { + "address": "0x14000a4a0", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r10 + 0x14], ecx" + }, + { + "address": "0x14000a4a4", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r10 + 0x10], eax" + }, + { + "address": "0x14000a4a8", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, 1" + }, + { + "address": "0x14000a4ab", + "size": 2, + "mnemonic": "je", + "operands": "0x14000a4c8" + } + ], + "successors": [ + "0x14000a4c8", + "0x14000a4ad" + ] + }, + { + "address": "0x14000a4c8", + "size": 16, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000a4c8", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdx]" + }, + { + "address": "0x14000a4cb", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rax]" + }, + { + "address": "0x14000a4cd", + "size": 4, + "mnemonic": "add", + "operands": "rax, 4" + }, + { + "address": "0x14000a4d1", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rdx], rax" + }, + { + "address": "0x14000a4d4", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r10 + 0x18], ecx" + }, + { + "address": "0x14000a4d8", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rdx]" + }, + { + "address": "0x14000a4db", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x14000a4de", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x14000a4e1", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r11 + 0x23d90]" + }, + { + "address": "0x14000a4ea", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r11 + 0x23da0]" + }, + { + "address": "0x14000a4f2", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, rax" + }, + { + "address": "0x14000a4f5", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x14000a4f8", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x14000a4fa", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [r9], rdx" + }, + { + "address": "0x14000a4fd", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r10 + 0x1c], eax" + }, + { + "address": "0x14000a501", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000a4ad", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a4ad", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, 2" + }, + { + "address": "0x14000a4b0", + "size": 2, + "mnemonic": "je", + "operands": "0x14000a4c8" + } + ], + "successors": [ + "0x14000a4c8", + "0x14000a4b2" + ] + }, + { + "address": "0x14000a4b2", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000a4b2", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, 3" + }, + { + "address": "0x14000a4b5", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000a501" + }, + { + "address": "0x14000a4b7", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdx]" + }, + { + "address": "0x14000a4ba", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rax]" + }, + { + "address": "0x14000a4bc", + "size": 4, + "mnemonic": "add", + "operands": "rax, 4" + }, + { + "address": "0x14000a4c0", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rdx], rax" + }, + { + "address": "0x14000a4c3", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r10 + 0x18], ecx" + }, + { + "address": "0x14000a4c7", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000aefc", + "name": "", + "blocks": [ + { + "address": "0x14000aefc", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000aefc", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000af01", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x14000af06", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x14000af0b", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000af0c", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000af10", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rcx" + }, + { + "address": "0x14000af13", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, r9d" + }, + { + "address": "0x14000af16", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x68]" + }, + { + "address": "0x14000af1b", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r8" + }, + { + "address": "0x14000af1e", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rdx" + }, + { + "address": "0x14000af21", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ac30" + }, + { + "address": "0x14000af26", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000af29", + "size": 2, + "mnemonic": "je", + "operands": "0x14000af67" + } + ], + "successors": [ + "0x14000af67", + "0x14000af2b" + ] + }, + { + "address": "0x14000af67", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000af67", + "size": 5, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rsp + 0x68]" + }, + { + "address": "0x14000af6c", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x27e65]" + }, + { + "address": "0x14000af73", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ac9c" + }, + { + "address": "0x14000af78", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, ebx" + }, + { + "address": "0x14000af7b", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rdi" + }, + { + "address": "0x14000af7e", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x14000af81", + "size": 3, + "mnemonic": "mov", + "operands": "r10, qword ptr [rax]" + }, + { + "address": "0x14000af84", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x260b5]" + }, + { + "address": "0x14000af8b", + "size": 3, + "mnemonic": "xor", + "operands": "r10, rax" + }, + { + "address": "0x14000af8e", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, eax" + }, + { + "address": "0x14000af90", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0x3f" + }, + { + "address": "0x14000af93", + "size": 3, + "mnemonic": "ror", + "operands": "r10, cl" + }, + { + "address": "0x14000af96", + "size": 3, + "mnemonic": "test", + "operands": "r10, r10" + }, + { + "address": "0x14000af99", + "size": 2, + "mnemonic": "je", + "operands": "0x14000afa0" + } + ], + "successors": [ + "0x14000afa0", + "0x14000af9b" + ] + }, + { + "address": "0x14000af2b", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000af2b", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax + 0x3b8]" + }, + { + "address": "0x14000af32", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000af35", + "size": 2, + "mnemonic": "je", + "operands": "0x14000af67" + } + ], + "successors": [ + "0x14000af67", + "0x14000af37" + ] + }, + { + "address": "0x14000afa0", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000afa0", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14000afa5", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbp" + }, + { + "address": "0x14000afa8", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14000afad", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afd4" + }, + { + "address": "0x14000afb2", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000af9b", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000af9b", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r10" + }, + { + "address": "0x14000af9e", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000af40" + } + ], + "successors": [ + "0x14000af40" + ] + }, + { + "address": "0x14000af37", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000af37", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, ebx" + }, + { + "address": "0x14000af3a", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rdi" + }, + { + "address": "0x14000af3d", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x14000af40", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14000af45", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rcx" + }, + { + "address": "0x14000af4a", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbp" + }, + { + "address": "0x14000af4d", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3a0" + }, + { + "address": "0x14000af52", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14000af57", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14000af5c", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14000af61", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000af65", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000af66", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000af40", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000af40", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14000af45", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rcx" + }, + { + "address": "0x14000af4a", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbp" + }, + { + "address": "0x14000af4d", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3a0" + }, + { + "address": "0x14000af52", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14000af57", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14000af5c", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14000af61", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000af65", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000af66", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000abc8", + "name": "", + "blocks": [ + { + "address": "0x14000abc8", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000abc8", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbx" + }, + { + "address": "0x14000abcd", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000abce", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000abd2", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [rcx], 0" + }, + { + "address": "0x14000abd6", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x14000abd9", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000ac1b" + }, + { + "address": "0x14000abdb", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x15517]" + }, + { + "address": "0x14000abe1", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rdi + 0x10], 0" + }, + { + "address": "0x14000abe5", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x30], eax" + }, + { + "address": "0x14000abe9", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000abf8" + }, + { + "address": "0x14000abeb", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rdi + 8], 0" + }, + { + "address": "0x14000abf0", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000abf2", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rdi + 0x10], 1" + }, + { + "address": "0x14000abf6", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000abfc" + } + ], + "successors": [ + "0x14000abfc" + ] + }, + { + "address": "0x14000abfc", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000abfc", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x30]" + }, + { + "address": "0x14000ac01", + "size": 5, + "mnemonic": "call", + "operands": "0x1400119b4" + }, + { + "address": "0x14000ac06", + "size": 4, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rsp + 0x30]" + }, + { + "address": "0x14000ac0a", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x14000ac0d", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rdi], rax" + }, + { + "address": "0x14000ac10", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x154ea]" + }, + { + "address": "0x14000ac16", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x14000ac19", + "size": 2, + "mnemonic": "je", + "operands": "0x14000ac29" + } + ], + "successors": [ + "0x14000ac29", + "0x14000ac1b" + ] + }, + { + "address": "0x14000ac29", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ac29", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x14000ac2e", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000ac1b", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000ac1b", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdi]" + }, + { + "address": "0x14000ac1e", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14000ac23", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000ac27", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000ac28", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000b210", + "name": "", + "blocks": [ + { + "address": "0x14000b210", + "size": 22, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000b210", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsp" + }, + { + "address": "0x14000b213", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x10], rbx" + }, + { + "address": "0x14000b217", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 8], rcx" + }, + { + "address": "0x14000b21b", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000b21c", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000b220", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x14000b223", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14000b226", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14000b229", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000b259" + }, + { + "address": "0x14000b22b", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rdx + 0x30], 1" + }, + { + "address": "0x14000b22f", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rdx + 0x2c], 0x16" + }, + { + "address": "0x14000b236", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax - 0x10], rdx" + }, + { + "address": "0x14000b23a", + "size": 4, + "mnemonic": "and", + "operands": "qword ptr [rax - 0x18], rcx" + }, + { + "address": "0x14000b23e", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x14000b241", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x14000b244", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000b246", + "size": 5, + "mnemonic": "call", + "operands": "0x14000aefc" + }, + { + "address": "0x14000b24b", + "size": 3, + "mnemonic": "or", + "operands": "eax, 0xffffffff" + }, + { + "address": "0x14000b24e", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14000b253", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000b257", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000b258", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000b468", + "name": "", + "blocks": [ + { + "address": "0x14000b468", + "size": 17, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b468", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000b46d", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r9" + }, + { + "address": "0x14000b472", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x14000b473", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000b474", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000b476", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x14000b47a", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r9" + }, + { + "address": "0x14000b47d", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, r8" + }, + { + "address": "0x14000b480", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rdx]" + }, + { + "address": "0x14000b482", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca20" + }, + { + "address": "0x14000b487", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14000b488", + "size": 7, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rip + 0x27959]" + }, + { + "address": "0x14000b48f", + "size": 7, + "mnemonic": "movsxd", + "operands": "rax, dword ptr [rip + 0x2794a]" + }, + { + "address": "0x14000b496", + "size": 4, + "mnemonic": "lea", + "operands": "r14, [rbx + rax*8]" + }, + { + "address": "0x14000b49a", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], rbx" + }, + { + "address": "0x14000b49f", + "size": 3, + "mnemonic": "cmp", + "operands": "rbx, r14" + }, + { + "address": "0x14000b4a2", + "size": 6, + "mnemonic": "je", + "operands": "0x14000b531" + } + ], + "successors": [ + "0x14000b531", + "0x14000b4a8" + ] + }, + { + "address": "0x14000b531", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000b531", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rdi]" + }, + { + "address": "0x14000b533", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca74" + }, + { + "address": "0x14000b538", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x80]" + }, + { + "address": "0x14000b540", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x60" + }, + { + "address": "0x14000b544", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000b546", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000b547", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14000b548", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000b4a8", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b4a8", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx]" + }, + { + "address": "0x14000b4ab", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rcx" + }, + { + "address": "0x14000b4b0", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rsi]" + }, + { + "address": "0x14000b4b3", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14000b4b6", + "size": 2, + "mnemonic": "je", + "operands": "0x14000b4da" + } + ], + "successors": [ + "0x14000b4da", + "0x14000b4b8" + ] + }, + { + "address": "0x14000b4da", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b4da", + "size": 4, + "mnemonic": "add", + "operands": "rbx, 8" + }, + { + "address": "0x14000b4de", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000b49a" + } + ], + "successors": [ + "0x14000b49a" + ] + }, + { + "address": "0x14000b4b8", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b4b8", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rcx + 0x14]" + }, + { + "address": "0x14000b4bb", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14000b4bc", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ecx" + }, + { + "address": "0x14000b4be", + "size": 3, + "mnemonic": "shr", + "operands": "eax, 0xd" + }, + { + "address": "0x14000b4c1", + "size": 2, + "mnemonic": "test", + "operands": "al, 1" + }, + { + "address": "0x14000b4c3", + "size": 2, + "mnemonic": "je", + "operands": "0x14000b4da" + } + ], + "successors": [ + "0x14000b4da", + "0x14000b4c5" + ] + }, + { + "address": "0x14000b49a", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b49a", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], rbx" + }, + { + "address": "0x14000b49f", + "size": 3, + "mnemonic": "cmp", + "operands": "rbx, r14" + }, + { + "address": "0x14000b4a2", + "size": 6, + "mnemonic": "je", + "operands": "0x14000b531" + } + ], + "successors": [ + "0x14000b531", + "0x14000b4a8" + ] + }, + { + "address": "0x14000b4c5", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b4c5", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ecx" + }, + { + "address": "0x14000b4c7", + "size": 2, + "mnemonic": "and", + "operands": "al, 3" + }, + { + "address": "0x14000b4c9", + "size": 2, + "mnemonic": "cmp", + "operands": "al, 2" + }, + { + "address": "0x14000b4cb", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000b4d2" + }, + { + "address": "0x14000b4cd", + "size": 3, + "mnemonic": "test", + "operands": "cl, 0xc0" + }, + { + "address": "0x14000b4d0", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000b4e0" + }, + { + "address": "0x14000b4d2", + "size": 4, + "mnemonic": "bt", + "operands": "ecx, 0xb" + }, + { + "address": "0x14000b4d6", + "size": 2, + "mnemonic": "jb", + "operands": "0x14000b4e0" + } + ], + "successors": [ + "0x14000b4e0", + "0x14000b4d8" + ] + }, + { + "address": "0x14000b4e0", + "size": 17, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b4e0", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rsi + 0x10]" + }, + { + "address": "0x14000b4e4", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsi + 8]" + }, + { + "address": "0x14000b4e8", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsi]" + }, + { + "address": "0x14000b4eb", + "size": 5, + "mnemonic": "lea", + "operands": "r8, [rsp + 0x20]" + }, + { + "address": "0x14000b4f0", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x40], r8" + }, + { + "address": "0x14000b4f5", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x48], rax" + }, + { + "address": "0x14000b4fa", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x50], rcx" + }, + { + "address": "0x14000b4ff", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x58], rdx" + }, + { + "address": "0x14000b504", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x20]" + }, + { + "address": "0x14000b509", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x14000b50e", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rax" + }, + { + "address": "0x14000b513", + "size": 5, + "mnemonic": "lea", + "operands": "r9, [rsp + 0x28]" + }, + { + "address": "0x14000b518", + "size": 5, + "mnemonic": "lea", + "operands": "r8, [rsp + 0x40]" + }, + { + "address": "0x14000b51d", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x30]" + }, + { + "address": "0x14000b522", + "size": 8, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x88]" + }, + { + "address": "0x14000b52a", + "size": 5, + "mnemonic": "call", + "operands": "0x14000b3cc" + }, + { + "address": "0x14000b52f", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000b4da" + } + ], + "successors": [ + "0x14000b4da" + ] + }, + { + "address": "0x14000b4d8", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b4d8", + "size": 2, + "mnemonic": "inc", + "operands": "dword ptr [rdx]" + }, + { + "address": "0x14000b4da", + "size": 4, + "mnemonic": "add", + "operands": "rbx, 8" + }, + { + "address": "0x14000b4de", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000b49a" + } + ], + "successors": [ + "0x14000b49a" + ] + } + ] + }, + { + "address": "0x14000b58c", + "name": "", + "blocks": [ + { + "address": "0x14000b58c", + "size": 26, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000b58c", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 8], cl" + }, + { + "address": "0x14000b590", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000b591", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14000b594", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x14000b598", + "size": 4, + "mnemonic": "and", + "operands": "dword ptr [rbp + 0x28], 0" + }, + { + "address": "0x14000b59c", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x28]" + }, + { + "address": "0x14000b5a0", + "size": 4, + "mnemonic": "and", + "operands": "dword ptr [rbp + 0x20], 0" + }, + { + "address": "0x14000b5a4", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp - 0x20]" + }, + { + "address": "0x14000b5a8", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x18], rax" + }, + { + "address": "0x14000b5ac", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbp - 0x18]" + }, + { + "address": "0x14000b5b0", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x10]" + }, + { + "address": "0x14000b5b4", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x10], rax" + }, + { + "address": "0x14000b5b8", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x1c]" + }, + { + "address": "0x14000b5bc", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x20]" + }, + { + "address": "0x14000b5c0", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 8], rax" + }, + { + "address": "0x14000b5c4", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x18]" + }, + { + "address": "0x14000b5c8", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 8" + }, + { + "address": "0x14000b5cd", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x20], eax" + }, + { + "address": "0x14000b5d0", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x1c], eax" + }, + { + "address": "0x14000b5d3", + "size": 5, + "mnemonic": "call", + "operands": "0x14000b468" + }, + { + "address": "0x14000b5d8", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp + 0x10], 0" + }, + { + "address": "0x14000b5dc", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbp + 0x20]" + }, + { + "address": "0x14000b5df", + "size": 4, + "mnemonic": "cmovne", + "operands": "eax, dword ptr [rbp + 0x28]" + }, + { + "address": "0x14000b5e3", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x40" + }, + { + "address": "0x14000b5e7", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000b5e8", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000b960", + "name": "", + "blocks": [ + { + "address": "0x14000b960", + "size": 26, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000b960", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsp" + }, + { + "address": "0x14000b963", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 8], rbx" + }, + { + "address": "0x14000b967", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x18], rsi" + }, + { + "address": "0x14000b96b", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x10], rdx" + }, + { + "address": "0x14000b96f", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000b970", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x14000b974", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rsp" + }, + { + "address": "0x14000b979", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r8" + }, + { + "address": "0x14000b97c", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdx" + }, + { + "address": "0x14000b97f", + "size": 2, + "mnemonic": "mov", + "operands": "esi, ecx" + }, + { + "address": "0x14000b981", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14000b984", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000b9bb" + }, + { + "address": "0x14000b986", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [r8 + 0x30], 1" + }, + { + "address": "0x14000b98b", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [r8 + 0x2c], 0x16" + }, + { + "address": "0x14000b993", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax - 0x20], r8" + }, + { + "address": "0x14000b997", + "size": 4, + "mnemonic": "and", + "operands": "qword ptr [rax - 0x28], rdx" + }, + { + "address": "0x14000b99b", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x14000b99e", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x14000b9a1", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14000b9a3", + "size": 5, + "mnemonic": "call", + "operands": "0x14000aefc" + }, + { + "address": "0x14000b9a8", + "size": 3, + "mnemonic": "or", + "operands": "eax, 0xffffffff" + }, + { + "address": "0x14000b9ab", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14000b9b0", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14000b9b5", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x40" + }, + { + "address": "0x14000b9b9", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000b9ba", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000d878", + "name": "", + "blocks": [ + { + "address": "0x14000d878", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000d878", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000d87c", + "size": 5, + "mnemonic": "call", + "operands": "0x140011924" + }, + { + "address": "0x14000d881", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x14000d884", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x23961]" + }, + { + "address": "0x14000d88b", + "size": 4, + "mnemonic": "add", + "operands": "rax, 0x20" + }, + { + "address": "0x14000d88f", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14000d892", + "size": 4, + "mnemonic": "cmove", + "operands": "rax, rdx" + }, + { + "address": "0x14000d896", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000d89a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000afb4", + "name": "", + "blocks": [ + { + "address": "0x14000afb4", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000afb4", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x38" + }, + { + "address": "0x14000afb8", + "size": 6, + "mnemonic": "and", + "operands": "qword ptr [rsp + 0x20], 0" + }, + { + "address": "0x14000afbe", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x14000afc1", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x14000afc4", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000afc6", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14000afc8", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ae60" + }, + { + "address": "0x14000afcd", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x38" + }, + { + "address": "0x14000afd1", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000bec8", + "name": "", + "blocks": [ + { + "address": "0x14000bec8", + "size": 29, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000bec8", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsp" + }, + { + "address": "0x14000becb", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x10], rbx" + }, + { + "address": "0x14000becf", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x18], rsi" + }, + { + "address": "0x14000bed3", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x20], rdi" + }, + { + "address": "0x14000bed7", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 8], rcx" + }, + { + "address": "0x14000bedb", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000bedd", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000bee1", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r9" + }, + { + "address": "0x14000bee4", + "size": 3, + "mnemonic": "mov", + "operands": "esi, r8d" + }, + { + "address": "0x14000bee7", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rdx" + }, + { + "address": "0x14000beea", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14000beed", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14000bef0", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000bf32" + }, + { + "address": "0x14000bef2", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [r9 + 0x30], 1" + }, + { + "address": "0x14000bef7", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [r9 + 0x2c], 0x16" + }, + { + "address": "0x14000beff", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rdi" + }, + { + "address": "0x14000bf04", + "size": 6, + "mnemonic": "and", + "operands": "qword ptr [rsp + 0x20], 0" + }, + { + "address": "0x14000bf0a", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x14000bf0d", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x14000bf10", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000bf12", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14000bf14", + "size": 5, + "mnemonic": "call", + "operands": "0x14000aefc" + }, + { + "address": "0x14000bf19", + "size": 3, + "mnemonic": "or", + "operands": "eax, 0xffffffff" + }, + { + "address": "0x14000bf1c", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14000bf21", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14000bf26", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x58]" + }, + { + "address": "0x14000bf2b", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000bf2f", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000bf31", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000c2a4", + "name": "", + "blocks": [ + { + "address": "0x14000c2a4", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000c2a4", + "size": 3, + "mnemonic": "mov", + "operands": "r11, rsp" + }, + { + "address": "0x14000c2a7", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r11 + 0x20], r9" + }, + { + "address": "0x14000c2ab", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r11 + 0x18], r8" + }, + { + "address": "0x14000c2af", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r11 + 0x10], rdx" + }, + { + "address": "0x14000c2b3", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r11 + 8], rcx" + }, + { + "address": "0x14000c2b7", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000c2b8", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14000c2bb", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x70" + }, + { + "address": "0x14000c2bf", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14000c2c2", + "size": 2, + "mnemonic": "je", + "operands": "0x14000c2f1" + } + ], + "successors": [ + "0x14000c2f1", + "0x14000c2c4" + ] + } + ] + }, + { + "address": "0x14000f858", + "name": "", + "blocks": [ + { + "address": "0x14000f858", + "size": 14, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000f858", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rdx" + }, + { + "address": "0x14000f85d", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 8], ecx" + }, + { + "address": "0x14000f861", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000f862", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14000f865", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x14000f869", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rbp - 0x40], 0" + }, + { + "address": "0x14000f86e", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rbp - 0x38], 0" + }, + { + "address": "0x14000f873", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, 5" + }, + { + "address": "0x14000f876", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14000f88c" + }, + { + "address": "0x14000f878", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x14000f87d", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0x16" + }, + { + "address": "0x14000f883", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afb4" + }, + { + "address": "0x14000f888", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000f88a", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000f8f3" + } + ], + "successors": [ + "0x14000f8f3" + ] + } + ] + }, + { + "address": "0x1400118c4", + "name": "", + "blocks": [ + { + "address": "0x1400118c4", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400118c4", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400118c8", + "size": 5, + "mnemonic": "call", + "operands": "0x140011924" + }, + { + "address": "0x1400118cd", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x1400118d0", + "size": 2, + "mnemonic": "je", + "operands": "0x1400118d7" + } + ], + "successors": [ + "0x1400118d7", + "0x1400118d2" + ] + }, + { + "address": "0x1400118d7", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400118d7", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x1400118dc", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400118d2", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400118d2", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400118d6", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140015a74", + "name": "", + "blocks": [ + { + "address": "0x140015a74", + "size": 13, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015a74", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140015a79", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rdi" + }, + { + "address": "0x140015a7e", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140015a7f", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x140015a82", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x70" + }, + { + "address": "0x140015a86", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rbp - 0x40], 0" + }, + { + "address": "0x140015a8b", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x38]" + }, + { + "address": "0x140015a8f", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x30], 0" + }, + { + "address": "0x140015a93", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 0" + }, + { + "address": "0x140015a97", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x140015a9b", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x140015a9f", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140015aa2", + "size": 2, + "mnemonic": "je", + "operands": "0x140015aa9" + } + ], + "successors": [ + "0x140015aa9", + "0x140015aa4" + ] + } + ] + }, + { + "address": "0x140015200", + "name": "", + "blocks": [ + ] + }, + { + "address": "0x140011b00", + "name": "", + "blocks": [ + ] + }, + { + "address": "0x140012358", + "name": "", + "blocks": [ + { + "address": "0x140012358", + "size": 84, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140012358", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x14001235c", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x23c9d]" + }, + { + "address": "0x140012363", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140012366", + "size": 2, + "mnemonic": "jne", + "operands": "0x140012384" + }, + { + "address": "0x140012368", + "size": 7, + "mnemonic": "lea", + "operands": "r9, [rip + 0x1451d]" + }, + { + "address": "0x14001236f", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x140012371", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip + 0x14510]" + }, + { + "address": "0x140012378", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x14511]" + }, + { + "address": "0x14001237f", + "size": 5, + "mnemonic": "call", + "operands": "0x140011c00" + }, + { + "address": "0x140012384", + "size": 5, + "mnemonic": "call", + "operands": "0x140011bc8" + }, + { + "address": "0x140012389", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x23c80]" + }, + { + "address": "0x140012390", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140012393", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400123b2" + }, + { + "address": "0x140012395", + "size": 7, + "mnemonic": "lea", + "operands": "r9, [rip + 0x14524]" + }, + { + "address": "0x14001239c", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip + 0x14515]" + }, + { + "address": "0x1400123a3", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x14516]" + }, + { + "address": "0x1400123aa", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rax + 2]" + }, + { + "address": "0x1400123ad", + "size": 5, + "mnemonic": "call", + "operands": "0x140011c00" + }, + { + "address": "0x1400123b2", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x23c6f]" + }, + { + "address": "0x1400123b9", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x1400123bc", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400123db" + }, + { + "address": "0x1400123be", + "size": 7, + "mnemonic": "lea", + "operands": "r9, [rip + 0x14533]" + }, + { + "address": "0x1400123c5", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip + 0x14524]" + }, + { + "address": "0x1400123cc", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x14525]" + }, + { + "address": "0x1400123d3", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rax + 5]" + }, + { + "address": "0x1400123d6", + "size": 5, + "mnemonic": "call", + "operands": "0x140011c00" + }, + { + "address": "0x1400123db", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x23c6e]" + }, + { + "address": "0x1400123e2", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x1400123e5", + "size": 2, + "mnemonic": "jne", + "operands": "0x140012404" + }, + { + "address": "0x1400123e7", + "size": 7, + "mnemonic": "lea", + "operands": "r9, [rip + 0x14522]" + }, + { + "address": "0x1400123ee", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip + 0x14513]" + }, + { + "address": "0x1400123f5", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x14514]" + }, + { + "address": "0x1400123fc", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rax + 0xa]" + }, + { + "address": "0x1400123ff", + "size": 5, + "mnemonic": "call", + "operands": "0x140011c00" + }, + { + "address": "0x140012404", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x23c5d]" + }, + { + "address": "0x14001240b", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001240e", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001242d" + }, + { + "address": "0x140012410", + "size": 7, + "mnemonic": "lea", + "operands": "r9, [rip + 0x14511]" + }, + { + "address": "0x140012417", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip + 0x14502]" + }, + { + "address": "0x14001241e", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x14503]" + }, + { + "address": "0x140012425", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rax + 0xd]" + }, + { + "address": "0x140012428", + "size": 5, + "mnemonic": "call", + "operands": "0x140011c00" + }, + { + "address": "0x14001242d", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x23c3c]" + }, + { + "address": "0x140012434", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140012437", + "size": 2, + "mnemonic": "jne", + "operands": "0x140012456" + }, + { + "address": "0x140012439", + "size": 7, + "mnemonic": "lea", + "operands": "r9, [rip + 0x14500]" + }, + { + "address": "0x140012440", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip + 0x144f1]" + }, + { + "address": "0x140012447", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x144f2]" + }, + { + "address": "0x14001244e", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rax + 0xe]" + }, + { + "address": "0x140012451", + "size": 5, + "mnemonic": "call", + "operands": "0x140011c00" + }, + { + "address": "0x140012456", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x23c2b]" + }, + { + "address": "0x14001245d", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140012460", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001247f" + }, + { + "address": "0x140012462", + "size": 7, + "mnemonic": "lea", + "operands": "r9, [rip + 0x144ff]" + }, + { + "address": "0x140012469", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip + 0x144f0]" + }, + { + "address": "0x140012470", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x144f1]" + }, + { + "address": "0x140012477", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rax + 0x11]" + }, + { + "address": "0x14001247a", + "size": 5, + "mnemonic": "call", + "operands": "0x140011c00" + }, + { + "address": "0x14001247f", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x23c0a]" + }, + { + "address": "0x140012486", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140012489", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400124a8" + }, + { + "address": "0x14001248b", + "size": 7, + "mnemonic": "lea", + "operands": "r9, [rip + 0x144f6]" + }, + { + "address": "0x140012492", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip + 0x144e7]" + }, + { + "address": "0x140012499", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x144e8]" + }, + { + "address": "0x1400124a0", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rax + 0x12]" + }, + { + "address": "0x1400124a3", + "size": 5, + "mnemonic": "call", + "operands": "0x140011c00" + }, + { + "address": "0x1400124a8", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x23be9]" + }, + { + "address": "0x1400124af", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x1400124b2", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400124d1" + }, + { + "address": "0x1400124b4", + "size": 7, + "mnemonic": "lea", + "operands": "r9, [rip + 0x144e5]" + }, + { + "address": "0x1400124bb", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip + 0x144d6]" + }, + { + "address": "0x1400124c2", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x144d7]" + }, + { + "address": "0x1400124c9", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rax + 0x13]" + }, + { + "address": "0x1400124cc", + "size": 5, + "mnemonic": "call", + "operands": "0x140011c00" + }, + { + "address": "0x1400124d1", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x23bc8]" + }, + { + "address": "0x1400124d8", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x1400124db", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400124fa" + }, + { + "address": "0x1400124dd", + "size": 7, + "mnemonic": "lea", + "operands": "r9, [rip + 0x144dc]" + }, + { + "address": "0x1400124e4", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip + 0x144cd]" + }, + { + "address": "0x1400124eb", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x144ce]" + }, + { + "address": "0x1400124f2", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rax + 0x14]" + }, + { + "address": "0x1400124f5", + "size": 5, + "mnemonic": "call", + "operands": "0x140011c00" + }, + { + "address": "0x1400124fa", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400124fe", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000cac8", + "name": "", + "blocks": [ + { + "address": "0x14000cac8", + "size": 19, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000cac8", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000cacd", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r9" + }, + { + "address": "0x14000cad2", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000cad3", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000cad7", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r9" + }, + { + "address": "0x14000cada", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r8" + }, + { + "address": "0x14000cadd", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rdx]" + }, + { + "address": "0x14000cadf", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca20" + }, + { + "address": "0x14000cae4", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14000cae5", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x14000cae8", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cb08" + }, + { + "address": "0x14000caed", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rax" + }, + { + "address": "0x14000caf0", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbx]" + }, + { + "address": "0x14000caf2", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca74" + }, + { + "address": "0x14000caf7", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdi" + }, + { + "address": "0x14000cafa", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000caff", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000cb03", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000cb04", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140017480", + "name": "", + "blocks": [ + { + "address": "0x140017480", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017480", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x140017484", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rcx" + }, + { + "address": "0x140017487", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001748a", + "size": 2, + "mnemonic": "je", + "operands": "0x14001749b" + } + ], + "successors": [ + "0x14001749b", + "0x14001748c" + ] + }, + { + "address": "0x14001749b", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001749b", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x1400174a0", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0x16" + }, + { + "address": "0x1400174a6", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afb4" + }, + { + "address": "0x1400174ab", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x16" + }, + { + "address": "0x1400174b0", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400174b4", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001748c", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001748c", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14001748f", + "size": 2, + "mnemonic": "je", + "operands": "0x14001749b" + } + ], + "successors": [ + "0x14001749b", + "0x140017491" + ] + }, + { + "address": "0x140017491", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140017491", + "size": 3, + "mnemonic": "test", + "operands": "r8, r8" + }, + { + "address": "0x140017494", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400174b5" + }, + { + "address": "0x140017496", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140017498", + "size": 3, + "mnemonic": "mov", + "operands": "word ptr [rcx], ax" + }, + { + "address": "0x14001749b", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x1400174a0", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0x16" + }, + { + "address": "0x1400174a6", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afb4" + }, + { + "address": "0x1400174ab", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x16" + }, + { + "address": "0x1400174b0", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400174b4", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000f8fc", + "name": "", + "blocks": [ + { + "address": "0x14000f8fc", + "size": 27, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000f8fc", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000f901", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x14000f906", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x14000f90b", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000f90c", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x14000f90e", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x14000f910", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000f912", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14000f914", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000f918", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14000f91b", + "size": 5, + "mnemonic": "mov", + "operands": "edi, 1" + }, + { + "address": "0x14000f920", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0x6a6" + }, + { + "address": "0x14000f925", + "size": 5, + "mnemonic": "call", + "operands": "0x140015200" + }, + { + "address": "0x14000f92a", + "size": 3, + "mnemonic": "xor", + "operands": "r12d, r12d" + }, + { + "address": "0x14000f92d", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rax" + }, + { + "address": "0x14000f930", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000f933", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000f952" + }, + { + "address": "0x14000f935", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14000f93a", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x68]" + }, + { + "address": "0x14000f93f", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x70]" + }, + { + "address": "0x14000f944", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000f948", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000f94a", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000f94c", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14000f94e", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14000f950", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000f951", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001a560", + "name": "", + "blocks": [ + { + "address": "0x14001a560", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a560", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14001a565", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001a566", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001a56a", + "size": 3, + "mnemonic": "movzx", + "operands": "eax, word ptr [rcx]" + }, + { + "address": "0x14001a56d", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x14001a570", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14001a573", + "size": 3, + "mnemonic": "test", + "operands": "ax, ax" + }, + { + "address": "0x14001a576", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a59d" + } + ], + "successors": [ + "0x14001a59d", + "0x14001a578" + ] + }, + { + "address": "0x14001a59d", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001a59d", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001a59f", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001a5a4", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001a5a8", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001a5a9", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001a578", + "size": 15, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001a578", + "size": 8, + "mnemonic": "nop", + "operands": "dword ptr [rax + rax]" + }, + { + "address": "0x14001a580", + "size": 3, + "mnemonic": "movzx", + "operands": "edx, ax" + }, + { + "address": "0x14001a583", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x14001a586", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e2cc" + }, + { + "address": "0x14001a58b", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001a58e", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001a5aa" + }, + { + "address": "0x14001a590", + "size": 4, + "mnemonic": "movzx", + "operands": "eax, word ptr [rbx + 2]" + }, + { + "address": "0x14001a594", + "size": 4, + "mnemonic": "add", + "operands": "rbx, 2" + }, + { + "address": "0x14001a598", + "size": 3, + "mnemonic": "test", + "operands": "ax, ax" + }, + { + "address": "0x14001a59b", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001a580" + }, + { + "address": "0x14001a59d", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001a59f", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001a5a4", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001a5a8", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001a5a9", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000fd80", + "name": "", + "blocks": [ + { + "address": "0x14000fd80", + "size": 30, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000fd80", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rbx" + }, + { + "address": "0x14000fd85", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000fd86", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x14000fd87", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000fd88", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x14000fd8a", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x14000fd8c", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000fd8e", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14000fd90", + "size": 8, + "mnemonic": "lea", + "operands": "rbp, [rsp - 0x230]" + }, + { + "address": "0x14000fd98", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x330" + }, + { + "address": "0x14000fd9f", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x2129a]" + }, + { + "address": "0x14000fda6", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x14000fda9", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x220], rax" + }, + { + "address": "0x14000fdb0", + "size": 3, + "mnemonic": "xor", + "operands": "r13d, r13d" + }, + { + "address": "0x14000fdb3", + "size": 3, + "mnemonic": "movsxd", + "operands": "r12, edx" + }, + { + "address": "0x14000fdb6", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x40], r13d" + }, + { + "address": "0x14000fdbb", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r8" + }, + { + "address": "0x14000fdbe", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x14000fdc1", + "size": 5, + "mnemonic": "call", + "operands": "0x1400118c4" + }, + { + "address": "0x14000fdc6", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp + 0x70]" + }, + { + "address": "0x14000fdca", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x83" + }, + { + "address": "0x14000fdd0", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x60]" + }, + { + "address": "0x14000fdd5", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x14000fdd8", + "size": 7, + "mnemonic": "lea", + "operands": "r14, [rax + 0x2c8]" + }, + { + "address": "0x14000fddf", + "size": 5, + "mnemonic": "lea", + "operands": "rax, [rsp + 0x40]" + }, + { + "address": "0x14000fde4", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x14000fde9", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], 0x55" + }, + { + "address": "0x14000fdf2", + "size": 5, + "mnemonic": "call", + "operands": "0x14000f36c" + }, + { + "address": "0x14000fdf7", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000fdfa", + "size": 6, + "mnemonic": "je", + "operands": "0x140010021" + } + ], + "successors": [ + "0x140010021", + "0x14000fe00" + ] + } + ] + }, + { + "address": "0x140011460", + "name": "", + "blocks": [ + { + "address": "0x140011460", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140011460", + "size": 3, + "mnemonic": "test", + "operands": "r8, r8" + }, + { + "address": "0x140011463", + "size": 2, + "mnemonic": "jne", + "operands": "0x140011468" + }, + { + "address": "0x140011465", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140011467", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001a500", + "name": "", + "blocks": [ + { + "address": "0x14001a500", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a500", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14001a505", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rsi" + }, + { + "address": "0x14001a50a", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001a50b", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001a50f", + "size": 3, + "mnemonic": "movzx", + "operands": "eax, word ptr [rcx]" + }, + { + "address": "0x14001a512", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rdx" + }, + { + "address": "0x14001a515", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x14001a518", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14001a51b", + "size": 3, + "mnemonic": "test", + "operands": "ax, ax" + }, + { + "address": "0x14001a51e", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a53d" + } + ], + "successors": [ + "0x14001a53d", + "0x14001a520" + ] + }, + { + "address": "0x14001a53d", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001a53d", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14001a542", + "size": 3, + "mnemonic": "sub", + "operands": "rbx, rdi" + }, + { + "address": "0x14001a545", + "size": 3, + "mnemonic": "sar", + "operands": "rbx, 1" + }, + { + "address": "0x14001a548", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x14001a54b", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001a550", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001a554", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001a555", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001a520", + "size": 17, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001a520", + "size": 3, + "mnemonic": "movzx", + "operands": "edx, ax" + }, + { + "address": "0x14001a523", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x14001a526", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e2cc" + }, + { + "address": "0x14001a52b", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001a52e", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001a53d" + }, + { + "address": "0x14001a530", + "size": 4, + "mnemonic": "movzx", + "operands": "eax, word ptr [rbx + 2]" + }, + { + "address": "0x14001a534", + "size": 4, + "mnemonic": "add", + "operands": "rbx, 2" + }, + { + "address": "0x14001a538", + "size": 3, + "mnemonic": "test", + "operands": "ax, ax" + }, + { + "address": "0x14001a53b", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001a520" + }, + { + "address": "0x14001a53d", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14001a542", + "size": 3, + "mnemonic": "sub", + "operands": "rbx, rdi" + }, + { + "address": "0x14001a545", + "size": 3, + "mnemonic": "sar", + "operands": "rbx, 1" + }, + { + "address": "0x14001a548", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x14001a54b", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001a550", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001a554", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001a555", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140017510", + "name": "", + "blocks": [ + { + "address": "0x140017510", + "size": 19, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140017510", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rsi" + }, + { + "address": "0x140017515", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140017516", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001751a", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, r9" + }, + { + "address": "0x14001751d", + "size": 3, + "mnemonic": "mov", + "operands": "r10, r8" + }, + { + "address": "0x140017520", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x140017523", + "size": 3, + "mnemonic": "mov", + "operands": "r11, rcx" + }, + { + "address": "0x140017526", + "size": 3, + "mnemonic": "test", + "operands": "r9, r9" + }, + { + "address": "0x140017529", + "size": 2, + "mnemonic": "jne", + "operands": "0x140017546" + }, + { + "address": "0x14001752b", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001752e", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001754b" + }, + { + "address": "0x140017530", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x140017533", + "size": 2, + "mnemonic": "jne", + "operands": "0x140017573" + }, + { + "address": "0x140017535", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x140017538", + "size": 3, + "mnemonic": "mov", + "operands": "eax, r8d" + }, + { + "address": "0x14001753b", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x38]" + }, + { + "address": "0x140017540", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140017544", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140017545", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400165b0", + "name": "", + "blocks": [ + { + "address": "0x1400165b0", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400165b0", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400165b4", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rcx" + }, + { + "address": "0x1400165b7", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x1400165ba", + "size": 2, + "mnemonic": "je", + "operands": "0x1400165cb" + } + ], + "successors": [ + "0x1400165cb", + "0x1400165bc" + ] + }, + { + "address": "0x1400165cb", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400165cb", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x1400165d0", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0x16" + }, + { + "address": "0x1400165d6", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afb4" + }, + { + "address": "0x1400165db", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x16" + }, + { + "address": "0x1400165e0", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400165e4", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400165bc", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400165bc", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x1400165bf", + "size": 2, + "mnemonic": "je", + "operands": "0x1400165cb" + } + ], + "successors": [ + "0x1400165cb", + "0x1400165c1" + ] + }, + { + "address": "0x1400165c1", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400165c1", + "size": 3, + "mnemonic": "test", + "operands": "r8, r8" + }, + { + "address": "0x1400165c4", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400165e5" + }, + { + "address": "0x1400165c6", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x1400165c8", + "size": 3, + "mnemonic": "mov", + "operands": "word ptr [rcx], ax" + }, + { + "address": "0x1400165cb", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x1400165d0", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0x16" + }, + { + "address": "0x1400165d6", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afb4" + }, + { + "address": "0x1400165db", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x16" + }, + { + "address": "0x1400165e0", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400165e4", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001ee30", + "name": "", + "blocks": [ + { + "address": "0x14001ee30", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ee30", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, rcx" + }, + { + "address": "0x14001ee33", + "size": 4, + "mnemonic": "cmp", + "operands": "r8, 8" + }, + { + "address": "0x14001ee37", + "size": 2, + "mnemonic": "jb", + "operands": "0x14001ee5b" + } + ], + "successors": [ + "0x14001ee5b", + "0x14001ee39" + ] + }, + { + "address": "0x14001ee5b", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ee5b", + "size": 3, + "mnemonic": "test", + "operands": "r8, r8" + }, + { + "address": "0x14001ee5e", + "size": 2, + "mnemonic": "je", + "operands": "0x14001ee6f" + } + ], + "successors": [ + "0x14001ee6f", + "0x14001ee60" + ] + }, + { + "address": "0x14001ee39", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ee39", + "size": 3, + "mnemonic": "test", + "operands": "cl, 7" + }, + { + "address": "0x14001ee3c", + "size": 2, + "mnemonic": "je", + "operands": "0x14001ee52" + } + ], + "successors": [ + "0x14001ee52", + "0x14001ee3e" + ] + }, + { + "address": "0x14001ee6f", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001ee6f", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rax" + }, + { + "address": "0x14001ee72", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001ee60", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001ee60", + "size": 2, + "mnemonic": "mov", + "operands": "al, byte ptr [rcx]" + }, + { + "address": "0x14001ee62", + "size": 3, + "mnemonic": "cmp", + "operands": "al, byte ptr [rcx + rdx]" + }, + { + "address": "0x14001ee65", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001ee73" + }, + { + "address": "0x14001ee67", + "size": 3, + "mnemonic": "inc", + "operands": "rcx" + }, + { + "address": "0x14001ee6a", + "size": 3, + "mnemonic": "dec", + "operands": "r8" + }, + { + "address": "0x14001ee6d", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001ee60" + }, + { + "address": "0x14001ee6f", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rax" + }, + { + "address": "0x14001ee72", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001ee52", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ee52", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r8" + }, + { + "address": "0x14001ee55", + "size": 4, + "mnemonic": "shr", + "operands": "r9, 3" + }, + { + "address": "0x14001ee59", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001ee7a" + }, + { + "address": "0x14001ee5b", + "size": 3, + "mnemonic": "test", + "operands": "r8, r8" + }, + { + "address": "0x14001ee5e", + "size": 2, + "mnemonic": "je", + "operands": "0x14001ee6f" + } + ], + "successors": [ + "0x14001ee6f", + "0x14001ee60" + ] + }, + { + "address": "0x14001ee3e", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ee3e", + "size": 2, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14001ee40", + "size": 2, + "mnemonic": "mov", + "operands": "al, byte ptr [rcx]" + }, + { + "address": "0x14001ee42", + "size": 3, + "mnemonic": "cmp", + "operands": "al, byte ptr [rcx + rdx]" + }, + { + "address": "0x14001ee45", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001ee73" + }, + { + "address": "0x14001ee47", + "size": 3, + "mnemonic": "inc", + "operands": "rcx" + }, + { + "address": "0x14001ee4a", + "size": 3, + "mnemonic": "dec", + "operands": "r8" + }, + { + "address": "0x14001ee4d", + "size": 3, + "mnemonic": "test", + "operands": "cl, 7" + }, + { + "address": "0x14001ee50", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001ee40" + }, + { + "address": "0x14001ee52", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r8" + }, + { + "address": "0x14001ee55", + "size": 4, + "mnemonic": "shr", + "operands": "r9, 3" + }, + { + "address": "0x14001ee59", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001ee7a" + }, + { + "address": "0x14001ee5b", + "size": 3, + "mnemonic": "test", + "operands": "r8, r8" + }, + { + "address": "0x14001ee5e", + "size": 2, + "mnemonic": "je", + "operands": "0x14001ee6f" + } + ], + "successors": [ + "0x14001ee6f", + "0x14001ee60" + ] + } + ] + }, + { + "address": "0x14001032c", + "name": "", + "blocks": [ + { + "address": "0x14001032c", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001032c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140010331", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140010332", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x140010336", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rdx + 0x10], 0" + }, + { + "address": "0x14001033a", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdx" + }, + { + "address": "0x14001033d", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x140010340", + "size": 2, + "mnemonic": "jne", + "operands": "0x140010392" + }, + { + "address": "0x140010342", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rdx + 8]" + }, + { + "address": "0x140010346", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rdx - 2]" + }, + { + "address": "0x14001034a", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, 1" + }, + { + "address": "0x14001034e", + "size": 2, + "mnemonic": "ja", + "operands": "0x140010392" + } + ], + "successors": [ + "0x140010392", + "0x140010350" + ] + }, + { + "address": "0x140010392", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140010392", + "size": 2, + "mnemonic": "xor", + "operands": "al, al" + }, + { + "address": "0x140010394", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140010399", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001039d", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001039e", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140010350", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010350", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx]" + }, + { + "address": "0x140010353", + "size": 5, + "mnemonic": "call", + "operands": "0x14001053c" + }, + { + "address": "0x140010358", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x14001035a", + "size": 2, + "mnemonic": "je", + "operands": "0x140010392" + } + ], + "successors": [ + "0x140010392", + "0x14001035c" + ] + }, + { + "address": "0x14001035c", + "size": 16, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001035c", + "size": 4, + "mnemonic": "mov", + "operands": "r9, qword ptr [rbx + 8]" + }, + { + "address": "0x140010360", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0x40" + }, + { + "address": "0x140010365", + "size": 3, + "mnemonic": "mov", + "operands": "r8, qword ptr [rbx]" + }, + { + "address": "0x140010368", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x14001036b", + "size": 5, + "mnemonic": "call", + "operands": "0x140017510" + }, + { + "address": "0x140010370", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140010372", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001039f" + }, + { + "address": "0x140010374", + "size": 4, + "mnemonic": "mov", + "operands": "r9, qword ptr [rbx + 8]" + }, + { + "address": "0x140010378", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rdi + 0x120]" + }, + { + "address": "0x14001037f", + "size": 3, + "mnemonic": "mov", + "operands": "r8, qword ptr [rbx]" + }, + { + "address": "0x140010382", + "size": 3, + "mnemonic": "lea", + "operands": "edx, [rax + 0x55]" + }, + { + "address": "0x140010385", + "size": 5, + "mnemonic": "call", + "operands": "0x140017510" + }, + { + "address": "0x14001038a", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001038c", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001039f" + }, + { + "address": "0x14001038e", + "size": 2, + "mnemonic": "mov", + "operands": "al, 1" + }, + { + "address": "0x140010390", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140010394" + } + ], + "successors": [ + "0x140010394" + ] + }, + { + "address": "0x140010394", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140010394", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140010399", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001039d", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001039e", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400104ac", + "name": "", + "blocks": [ + { + "address": "0x1400104ac", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400104ac", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x1400104b1", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x1400104b2", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x1400104b6", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rdx + 0x10], 0" + }, + { + "address": "0x1400104ba", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdx" + }, + { + "address": "0x1400104bd", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x1400104c0", + "size": 2, + "mnemonic": "jne", + "operands": "0x140010518" + }, + { + "address": "0x1400104c2", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 4" + }, + { + "address": "0x1400104c7", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [rbx + 8], rdx" + }, + { + "address": "0x1400104cb", + "size": 2, + "mnemonic": "jne", + "operands": "0x140010518" + }, + { + "address": "0x1400104cd", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx]" + }, + { + "address": "0x1400104d0", + "size": 5, + "mnemonic": "call", + "operands": "0x14001053c" + }, + { + "address": "0x1400104d5", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x1400104d7", + "size": 2, + "mnemonic": "je", + "operands": "0x140010518" + } + ], + "successors": [ + "0x140010518", + "0x1400104d9" + ] + }, + { + "address": "0x140010518", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140010518", + "size": 2, + "mnemonic": "xor", + "operands": "al, al" + }, + { + "address": "0x14001051a", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14001051f", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140010523", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140010524", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400104d9", + "size": 16, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400104d9", + "size": 6, + "mnemonic": "mov", + "operands": "r9d, 1" + }, + { + "address": "0x1400104df", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip + 0x137e2]" + }, + { + "address": "0x1400104e6", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rdi + 0x120]" + }, + { + "address": "0x1400104ed", + "size": 4, + "mnemonic": "lea", + "operands": "edx, [r9 + 0x54]" + }, + { + "address": "0x1400104f1", + "size": 5, + "mnemonic": "call", + "operands": "0x14001a3c0" + }, + { + "address": "0x1400104f6", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x1400104f8", + "size": 2, + "mnemonic": "jne", + "operands": "0x140010525" + }, + { + "address": "0x1400104fa", + "size": 4, + "mnemonic": "mov", + "operands": "r9, qword ptr [rbx + 8]" + }, + { + "address": "0x1400104fe", + "size": 3, + "mnemonic": "lea", + "operands": "edx, [rax + 0x55]" + }, + { + "address": "0x140010501", + "size": 3, + "mnemonic": "mov", + "operands": "r8, qword ptr [rbx]" + }, + { + "address": "0x140010504", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rdi + 0x120]" + }, + { + "address": "0x14001050b", + "size": 5, + "mnemonic": "call", + "operands": "0x14001a3c0" + }, + { + "address": "0x140010510", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140010512", + "size": 2, + "mnemonic": "jne", + "operands": "0x140010525" + }, + { + "address": "0x140010514", + "size": 2, + "mnemonic": "mov", + "operands": "al, 1" + }, + { + "address": "0x140010516", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001051a" + } + ], + "successors": [ + "0x14001051a" + ] + }, + { + "address": "0x14001051a", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001051a", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14001051f", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140010523", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140010524", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400103b8", + "name": "", + "blocks": [ + { + "address": "0x1400103b8", + "size": 26, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400103b8", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x1400103bd", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rbp" + }, + { + "address": "0x1400103c2", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x1400103c3", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x1400103c4", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x1400103c6", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x1400103ca", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rdx + 0x10], 0" + }, + { + "address": "0x1400103ce", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdx" + }, + { + "address": "0x1400103d1", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rcx" + }, + { + "address": "0x1400103d4", + "size": 6, + "mnemonic": "jne", + "operands": "0x140010480" + }, + { + "address": "0x1400103da", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 2" + }, + { + "address": "0x1400103df", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [rbx + 8], rdx" + }, + { + "address": "0x1400103e3", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400103f1" + }, + { + "address": "0x1400103e5", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx]" + }, + { + "address": "0x1400103e8", + "size": 5, + "mnemonic": "call", + "operands": "0x14001053c" + }, + { + "address": "0x1400103ed", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x1400103ef", + "size": 2, + "mnemonic": "jne", + "operands": "0x140010428" + }, + { + "address": "0x1400103f1", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rbx + 8], 3" + }, + { + "address": "0x1400103f6", + "size": 6, + "mnemonic": "jne", + "operands": "0x140010480" + }, + { + "address": "0x1400103fc", + "size": 3, + "mnemonic": "mov", + "operands": "r14, qword ptr [rbx]" + }, + { + "address": "0x1400103ff", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x140010401", + "size": 5, + "mnemonic": "movzx", + "operands": "esi, word ptr [r14 + rdi*2]" + }, + { + "address": "0x140010406", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cdf4" + }, + { + "address": "0x14001040b", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0xff" + }, + { + "address": "0x140010410", + "size": 3, + "mnemonic": "cmp", + "operands": "si, cx" + }, + { + "address": "0x140010413", + "size": 2, + "mnemonic": "ja", + "operands": "0x140010480" + } + ], + "successors": [ + "0x140010480", + "0x140010415" + ] + }, + { + "address": "0x140010480", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140010480", + "size": 2, + "mnemonic": "xor", + "operands": "al, al" + }, + { + "address": "0x140010482", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x50]" + }, + { + "address": "0x140010487", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14001048c", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140010490", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140010492", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140010493", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140010494", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140010415", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010415", + "size": 4, + "mnemonic": "movzx", + "operands": "eax, word ptr [rax + rsi*2]" + }, + { + "address": "0x140010419", + "size": 4, + "mnemonic": "bt", + "operands": "eax, 2" + }, + { + "address": "0x14001041d", + "size": 2, + "mnemonic": "jae", + "operands": "0x140010480" + }, + { + "address": "0x14001041f", + "size": 3, + "mnemonic": "inc", + "operands": "rdi" + }, + { + "address": "0x140010422", + "size": 4, + "mnemonic": "cmp", + "operands": "rdi, 3" + }, + { + "address": "0x140010426", + "size": 2, + "mnemonic": "jb", + "operands": "0x140010401" + } + ], + "successors": [ + "0x140010401", + "0x140010428" + ] + }, + { + "address": "0x140010401", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010401", + "size": 5, + "mnemonic": "movzx", + "operands": "esi, word ptr [r14 + rdi*2]" + }, + { + "address": "0x140010406", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cdf4" + }, + { + "address": "0x14001040b", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0xff" + }, + { + "address": "0x140010410", + "size": 3, + "mnemonic": "cmp", + "operands": "si, cx" + }, + { + "address": "0x140010413", + "size": 2, + "mnemonic": "ja", + "operands": "0x140010480" + } + ], + "successors": [ + "0x140010480", + "0x140010415" + ] + }, + { + "address": "0x140010428", + "size": 25, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010428", + "size": 4, + "mnemonic": "mov", + "operands": "r9, qword ptr [rbx + 8]" + }, + { + "address": "0x14001042c", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x80]" + }, + { + "address": "0x140010433", + "size": 3, + "mnemonic": "mov", + "operands": "r8, qword ptr [rbx]" + }, + { + "address": "0x140010436", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0x40" + }, + { + "address": "0x14001043b", + "size": 5, + "mnemonic": "call", + "operands": "0x140017510" + }, + { + "address": "0x140010440", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140010442", + "size": 2, + "mnemonic": "jne", + "operands": "0x140010495" + }, + { + "address": "0x140010444", + "size": 3, + "mnemonic": "lea", + "operands": "esi, [rax + 0x55]" + }, + { + "address": "0x140010447", + "size": 7, + "mnemonic": "lea", + "operands": "rdi, [rbp + 0x120]" + }, + { + "address": "0x14001044e", + "size": 2, + "mnemonic": "mov", + "operands": "edx, esi" + }, + { + "address": "0x140010450", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140010453", + "size": 4, + "mnemonic": "lea", + "operands": "r9d, [rax + 1]" + }, + { + "address": "0x140010457", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip + 0x1386a]" + }, + { + "address": "0x14001045e", + "size": 5, + "mnemonic": "call", + "operands": "0x14001a3c0" + }, + { + "address": "0x140010463", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140010465", + "size": 2, + "mnemonic": "jne", + "operands": "0x140010495" + }, + { + "address": "0x140010467", + "size": 4, + "mnemonic": "mov", + "operands": "r9, qword ptr [rbx + 8]" + }, + { + "address": "0x14001046b", + "size": 2, + "mnemonic": "mov", + "operands": "edx, esi" + }, + { + "address": "0x14001046d", + "size": 3, + "mnemonic": "mov", + "operands": "r8, qword ptr [rbx]" + }, + { + "address": "0x140010470", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140010473", + "size": 5, + "mnemonic": "call", + "operands": "0x14001a3c0" + }, + { + "address": "0x140010478", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001047a", + "size": 2, + "mnemonic": "jne", + "operands": "0x140010495" + }, + { + "address": "0x14001047c", + "size": 2, + "mnemonic": "mov", + "operands": "al, 1" + }, + { + "address": "0x14001047e", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140010482" + } + ], + "successors": [ + "0x140010482" + ] + }, + { + "address": "0x140010482", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140010482", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x50]" + }, + { + "address": "0x140010487", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14001048c", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140010490", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140010492", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140010493", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140010494", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400102e4", + "name": "", + "blocks": [ + { + "address": "0x1400102e4", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400102e4", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x38" + }, + { + "address": "0x1400102e8", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rdx + 0x10], 2" + }, + { + "address": "0x1400102ec", + "size": 2, + "mnemonic": "je", + "operands": "0x1400102f5" + } + ], + "successors": [ + "0x1400102f5", + "0x1400102ee" + ] + }, + { + "address": "0x1400102f5", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400102f5", + "size": 4, + "mnemonic": "mov", + "operands": "r9, qword ptr [rdx + 8]" + }, + { + "address": "0x1400102f9", + "size": 7, + "mnemonic": "add", + "operands": "rcx, 0x100" + }, + { + "address": "0x140010300", + "size": 3, + "mnemonic": "mov", + "operands": "r8, qword ptr [rdx]" + }, + { + "address": "0x140010303", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0x10" + }, + { + "address": "0x140010308", + "size": 5, + "mnemonic": "call", + "operands": "0x140017510" + }, + { + "address": "0x14001030d", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001030f", + "size": 2, + "mnemonic": "jne", + "operands": "0x140010315" + }, + { + "address": "0x140010311", + "size": 2, + "mnemonic": "mov", + "operands": "al, 1" + }, + { + "address": "0x140010313", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400102f0" + } + ], + "successors": [ + "0x1400102f0" + ] + }, + { + "address": "0x1400102ee", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400102ee", + "size": 2, + "mnemonic": "xor", + "operands": "al, al" + }, + { + "address": "0x1400102f0", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x38" + }, + { + "address": "0x1400102f4", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400102f0", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400102f0", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x38" + }, + { + "address": "0x1400102f4", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400105f4", + "name": "", + "blocks": [ + { + "address": "0x1400105f4", + "size": 19, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400105f4", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x1400105f9", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r9" + }, + { + "address": "0x1400105fe", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x1400105ff", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140010603", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r9" + }, + { + "address": "0x140010606", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r8" + }, + { + "address": "0x140010609", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rdx]" + }, + { + "address": "0x14001060b", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca20" + }, + { + "address": "0x140010610", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140010611", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140010614", + "size": 5, + "mnemonic": "call", + "operands": "0x14001066c" + }, + { + "address": "0x140010619", + "size": 2, + "mnemonic": "mov", + "operands": "edi, eax" + }, + { + "address": "0x14001061b", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbx]" + }, + { + "address": "0x14001061d", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca74" + }, + { + "address": "0x140010622", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x140010624", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140010629", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001062d", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001062e", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140010c10", + "name": "", + "blocks": [ + { + "address": "0x140010c10", + "size": 22, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010c10", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rbx" + }, + { + "address": "0x140010c15", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rcx" + }, + { + "address": "0x140010c1a", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140010c1b", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140010c1c", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140010c1d", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140010c1f", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140010c21", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140010c23", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140010c25", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0xa0" + }, + { + "address": "0x140010c2c", + "size": 3, + "mnemonic": "mov", + "operands": "r12, qword ptr [rdx]" + }, + { + "address": "0x140010c2f", + "size": 3, + "mnemonic": "xor", + "operands": "r13d, r13d" + }, + { + "address": "0x140010c32", + "size": 4, + "mnemonic": "movzx", + "operands": "esi, r9b" + }, + { + "address": "0x140010c36", + "size": 3, + "mnemonic": "mov", + "operands": "r15d, r8d" + }, + { + "address": "0x140010c39", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x90], r12" + }, + { + "address": "0x140010c41", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x140010c44", + "size": 3, + "mnemonic": "test", + "operands": "r12, r12" + }, + { + "address": "0x140010c47", + "size": 2, + "mnemonic": "jne", + "operands": "0x140010c5b" + }, + { + "address": "0x140010c49", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x140010c4e", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0x16" + }, + { + "address": "0x140010c54", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afb4" + }, + { + "address": "0x140010c59", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140010c8d" + } + ], + "successors": [ + "0x140010c8d" + ] + } + ] + }, + { + "address": "0x140011494", + "name": "", + "blocks": [ + { + "address": "0x140011494", + "size": 19, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140011494", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140011499", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r9" + }, + { + "address": "0x14001149e", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001149f", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400114a3", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r9" + }, + { + "address": "0x1400114a6", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r8" + }, + { + "address": "0x1400114a9", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rdx]" + }, + { + "address": "0x1400114ab", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca20" + }, + { + "address": "0x1400114b0", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x1400114b1", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdi]" + }, + { + "address": "0x1400114b4", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax]" + }, + { + "address": "0x1400114b7", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0x88]" + }, + { + "address": "0x1400114be", + "size": 3, + "mnemonic": "lock inc", + "operands": "dword ptr [rax]" + }, + { + "address": "0x1400114c1", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbx]" + }, + { + "address": "0x1400114c3", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca74" + }, + { + "address": "0x1400114c8", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x1400114cd", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400114d1", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400114d2", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140011514", + "name": "", + "blocks": [ + { + "address": "0x140011514", + "size": 22, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140011514", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140011519", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r9" + }, + { + "address": "0x14001151e", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001151f", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140011523", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r9" + }, + { + "address": "0x140011526", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r8" + }, + { + "address": "0x140011529", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rdx]" + }, + { + "address": "0x14001152b", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca20" + }, + { + "address": "0x140011530", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140011531", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdi + 8]" + }, + { + "address": "0x140011535", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rax]" + }, + { + "address": "0x140011538", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdi]" + }, + { + "address": "0x14001153b", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rdx]" + }, + { + "address": "0x14001153e", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx]" + }, + { + "address": "0x140011541", + "size": 5, + "mnemonic": "call", + "operands": "0x14001185c" + }, + { + "address": "0x140011546", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140011547", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbx]" + }, + { + "address": "0x140011549", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca74" + }, + { + "address": "0x14001154e", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140011553", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140011557", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140011558", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001155c", + "name": "", + "blocks": [ + { + "address": "0x14001155c", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001155c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140011561", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r9" + }, + { + "address": "0x140011566", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140011567", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001156b", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r9" + }, + { + "address": "0x14001156e", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r8" + }, + { + "address": "0x140011571", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rdx]" + }, + { + "address": "0x140011573", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca20" + }, + { + "address": "0x140011578", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140011579", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdi]" + }, + { + "address": "0x14001157c", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax]" + }, + { + "address": "0x14001157f", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x88]" + }, + { + "address": "0x140011586", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140011589", + "size": 2, + "mnemonic": "je", + "operands": "0x1400115a9" + } + ], + "successors": [ + "0x1400115a9", + "0x14001158b" + ] + }, + { + "address": "0x1400115a9", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400115a9", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbx]" + }, + { + "address": "0x1400115ab", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca74" + }, + { + "address": "0x1400115b0", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x1400115b5", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400115b9", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400115ba", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001158b", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001158b", + "size": 3, + "mnemonic": "or", + "operands": "eax, 0xffffffff" + }, + { + "address": "0x14001158e", + "size": 4, + "mnemonic": "lock xadd", + "operands": "dword ptr [rcx], eax" + }, + { + "address": "0x140011592", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x140011595", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400115a9" + }, + { + "address": "0x140011597", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x201a2]" + }, + { + "address": "0x14001159e", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, rax" + }, + { + "address": "0x1400115a1", + "size": 2, + "mnemonic": "je", + "operands": "0x1400115a9" + } + ], + "successors": [ + "0x1400115a9", + "0x1400115a3" + ] + }, + { + "address": "0x1400115a3", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400115a3", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x1400115a8", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x1400115a9", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbx]" + }, + { + "address": "0x1400115ab", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca74" + }, + { + "address": "0x1400115b0", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x1400115b5", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400115b9", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400115ba", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400114d4", + "name": "", + "blocks": [ + { + "address": "0x1400114d4", + "size": 20, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400114d4", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x1400114d9", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r9" + }, + { + "address": "0x1400114de", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x1400114df", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400114e3", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r9" + }, + { + "address": "0x1400114e6", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r8" + }, + { + "address": "0x1400114e9", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rdx]" + }, + { + "address": "0x1400114eb", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca20" + }, + { + "address": "0x1400114f0", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x1400114f1", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdi]" + }, + { + "address": "0x1400114f4", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x1400114f6", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx]" + }, + { + "address": "0x1400114f9", + "size": 5, + "mnemonic": "call", + "operands": "0x14001185c" + }, + { + "address": "0x1400114fe", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x1400114ff", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbx]" + }, + { + "address": "0x140011501", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca74" + }, + { + "address": "0x140011506", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001150b", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001150f", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140011510", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000d940", + "name": "", + "blocks": [ + { + "address": "0x14000d940", + "size": 30, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000d940", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000d945", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rsi" + }, + { + "address": "0x14000d94a", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000d94b", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000d94f", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x14000d952", + "size": 5, + "mnemonic": "call", + "operands": "0x14000abc8" + }, + { + "address": "0x14000d957", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rdi + 0x18]" + }, + { + "address": "0x14000d95b", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x14000d95e", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rax" + }, + { + "address": "0x14000d961", + "size": 7, + "mnemonic": "mov", + "operands": "r8, qword ptr [rax + 0x90]" + }, + { + "address": "0x14000d968", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rdx], r8" + }, + { + "address": "0x14000d96b", + "size": 7, + "mnemonic": "mov", + "operands": "r8, qword ptr [rax + 0x88]" + }, + { + "address": "0x14000d972", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rdi + 0x20], r8" + }, + { + "address": "0x14000d976", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [rdi + 8]" + }, + { + "address": "0x14000d97a", + "size": 5, + "mnemonic": "call", + "operands": "0x140015b60" + }, + { + "address": "0x14000d97f", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [rdi + 8]" + }, + { + "address": "0x14000d983", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rdi + 0x20]" + }, + { + "address": "0x14000d987", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x14000d98a", + "size": 5, + "mnemonic": "call", + "operands": "0x140015bcc" + }, + { + "address": "0x14000d98f", + "size": 6, + "mnemonic": "mov", + "operands": "eax, dword ptr [rsi + 0x3a8]" + }, + { + "address": "0x14000d995", + "size": 2, + "mnemonic": "test", + "operands": "al, 2" + }, + { + "address": "0x14000d997", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000d9a6" + }, + { + "address": "0x14000d999", + "size": 3, + "mnemonic": "or", + "operands": "eax, 2" + }, + { + "address": "0x14000d99c", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rsi + 0x3a8], eax" + }, + { + "address": "0x14000d9a2", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rdi + 0x28], 2" + }, + { + "address": "0x14000d9a6", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000d9ab", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14000d9b0", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000d9b4", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000d9b5", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140016e74", + "name": "", + "blocks": [ + { + "address": "0x140016e74", + "size": 17, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016e74", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbx" + }, + { + "address": "0x140016e79", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rbp" + }, + { + "address": "0x140016e7e", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rsi" + }, + { + "address": "0x140016e83", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140016e84", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140016e86", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140016e88", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140016e8a", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140016e8c", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x140016e90", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rdx]" + }, + { + "address": "0x140016e93", + "size": 3, + "mnemonic": "xor", + "operands": "r13d, r13d" + }, + { + "address": "0x140016e96", + "size": 3, + "mnemonic": "mov", + "operands": "r12, r9" + }, + { + "address": "0x140016e99", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, r8" + }, + { + "address": "0x140016e9c", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rdx" + }, + { + "address": "0x140016e9f", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rcx" + }, + { + "address": "0x140016ea2", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140016ea5", + "size": 6, + "mnemonic": "je", + "operands": "0x140016f96" + } + ], + "successors": [ + "0x140016f96", + "0x140016eab" + ] + }, + { + "address": "0x140016f96", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016f96", + "size": 8, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x80]" + }, + { + "address": "0x140016f9e", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r13" + }, + { + "address": "0x140016fa1", + "size": 3, + "mnemonic": "cmp", + "operands": "byte ptr [rdi], r13b" + }, + { + "address": "0x140016fa4", + "size": 2, + "mnemonic": "jne", + "operands": "0x140016fae" + }, + { + "address": "0x140016fa6", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 1" + }, + { + "address": "0x140016fac", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140016fcb" + } + ], + "successors": [ + "0x140016fcb" + ] + }, + { + "address": "0x140016eab", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016eab", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140016eae", + "size": 3, + "mnemonic": "test", + "operands": "r8, r8" + }, + { + "address": "0x140016eb1", + "size": 6, + "mnemonic": "je", + "operands": "0x140016f6a" + } + ], + "successors": [ + "0x140016f6a", + "0x140016eb7" + ] + }, + { + "address": "0x140016fcb", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016fcb", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r12" + }, + { + "address": "0x140016fce", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rsi" + }, + { + "address": "0x140016fd3", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rdi" + }, + { + "address": "0x140016fd6", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x140016fd8", + "size": 5, + "mnemonic": "call", + "operands": "0x140016bc8" + }, + { + "address": "0x140016fdd", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, -1" + }, + { + "address": "0x140016fe1", + "size": 2, + "mnemonic": "je", + "operands": "0x140016ffd" + } + ], + "successors": [ + "0x140016ffd", + "0x140016fe3" + ] + }, + { + "address": "0x140016f6a", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016f6a", + "size": 3, + "mnemonic": "sub", + "operands": "rbx, rbp" + }, + { + "address": "0x140016f6d", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [r14], rdi" + }, + { + "address": "0x140016f70", + "size": 3, + "mnemonic": "sar", + "operands": "rbx, 1" + }, + { + "address": "0x140016f73", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140016f76", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14001700c" + } + ], + "successors": [ + "0x14001700c" + ] + }, + { + "address": "0x140016eb7", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016eb7", + "size": 8, + "mnemonic": "mov", + "operands": "r15, qword ptr [rsp + 0x80]" + }, + { + "address": "0x140016ebf", + "size": 3, + "mnemonic": "cmp", + "operands": "byte ptr [rdi], r13b" + }, + { + "address": "0x140016ec2", + "size": 2, + "mnemonic": "jne", + "operands": "0x140016ecc" + }, + { + "address": "0x140016ec4", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 1" + }, + { + "address": "0x140016eca", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140016ee9" + } + ], + "successors": [ + "0x140016ee9" + ] + }, + { + "address": "0x140016ffd", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140016ffd", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rsi + 0x30], 1" + }, + { + "address": "0x140017001", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rsi + 0x2c], 0x2a" + }, + { + "address": "0x140017008", + "size": 4, + "mnemonic": "or", + "operands": "rax, 0xffffffffffffffff" + }, + { + "address": "0x14001700c", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x68]" + }, + { + "address": "0x140017011", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140017016", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x78]" + }, + { + "address": "0x14001701b", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001701f", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140017021", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140017023", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140017025", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140017027", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140017028", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140016fe3", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016fe3", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140016fe6", + "size": 2, + "mnemonic": "je", + "operands": "0x140016f73" + } + ], + "successors": [ + "0x140016f73", + "0x140016fe8" + ] + }, + { + "address": "0x14001700c", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001700c", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x68]" + }, + { + "address": "0x140017011", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140017016", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x78]" + }, + { + "address": "0x14001701b", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001701f", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140017021", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140017023", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140017025", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140017027", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140017028", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140016ee9", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016ee9", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r12" + }, + { + "address": "0x140016eec", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x60], r13d" + }, + { + "address": "0x140016ef1", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rdi" + }, + { + "address": "0x140016ef4", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r15" + }, + { + "address": "0x140016ef9", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x60]" + }, + { + "address": "0x140016efe", + "size": 5, + "mnemonic": "call", + "operands": "0x140016bc8" + }, + { + "address": "0x140016f03", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rax" + }, + { + "address": "0x140016f06", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, -1" + }, + { + "address": "0x140016f0a", + "size": 2, + "mnemonic": "je", + "operands": "0x140016f84" + } + ], + "successors": [ + "0x140016f84", + "0x140016f0c" + ] + }, + { + "address": "0x140016f73", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016f73", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140016f76", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14001700c" + } + ], + "successors": [ + "0x14001700c" + ] + }, + { + "address": "0x140016fe8", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016fe8", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbx + 1]" + }, + { + "address": "0x140016fec", + "size": 3, + "mnemonic": "add", + "operands": "rdi, rax" + }, + { + "address": "0x140016fef", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, 4" + }, + { + "address": "0x140016ff3", + "size": 4, + "mnemonic": "cmovne", + "operands": "rcx, rbx" + }, + { + "address": "0x140016ff7", + "size": 4, + "mnemonic": "lea", + "operands": "rbx, [rcx + 1]" + }, + { + "address": "0x140016ffb", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140016fa1" + } + ], + "successors": [ + "0x140016fa1" + ] + }, + { + "address": "0x140016f84", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016f84", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [r14], rdi" + }, + { + "address": "0x140016f87", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [r15 + 0x30], 1" + }, + { + "address": "0x140016f8c", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [r15 + 0x2c], 0x2a" + }, + { + "address": "0x140016f94", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140017008" + } + ], + "successors": [ + "0x140017008" + ] + }, + { + "address": "0x140016f0c", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016f0c", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140016f0f", + "size": 2, + "mnemonic": "je", + "operands": "0x140016f7b" + } + ], + "successors": [ + "0x140016f7b", + "0x140016f11" + ] + }, + { + "address": "0x140016fa1", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016fa1", + "size": 3, + "mnemonic": "cmp", + "operands": "byte ptr [rdi], r13b" + }, + { + "address": "0x140016fa4", + "size": 2, + "mnemonic": "jne", + "operands": "0x140016fae" + }, + { + "address": "0x140016fa6", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 1" + }, + { + "address": "0x140016fac", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140016fcb" + } + ], + "successors": [ + "0x140016fcb" + ] + }, + { + "address": "0x140017008", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140017008", + "size": 4, + "mnemonic": "or", + "operands": "rax, 0xffffffffffffffff" + }, + { + "address": "0x14001700c", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x68]" + }, + { + "address": "0x140017011", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140017016", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x78]" + }, + { + "address": "0x14001701b", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001701f", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140017021", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140017023", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140017025", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140017027", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140017028", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140016f7b", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016f7b", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r13" + }, + { + "address": "0x140016f7e", + "size": 4, + "mnemonic": "mov", + "operands": "word ptr [rbx], r13w" + }, + { + "address": "0x140016f82", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140016f6a" + } + ], + "successors": [ + "0x140016f6a" + ] + }, + { + "address": "0x140016f11", + "size": 28, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016f11", + "size": 4, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rsp + 0x60]" + }, + { + "address": "0x140016f15", + "size": 6, + "mnemonic": "cmp", + "operands": "ecx, 0xffff" + }, + { + "address": "0x140016f1b", + "size": 2, + "mnemonic": "jbe", + "operands": "0x140016f56" + }, + { + "address": "0x140016f1d", + "size": 4, + "mnemonic": "cmp", + "operands": "rsi, 1" + }, + { + "address": "0x140016f21", + "size": 2, + "mnemonic": "jbe", + "operands": "0x140016f6a" + }, + { + "address": "0x140016f23", + "size": 6, + "mnemonic": "add", + "operands": "ecx, 0xffff0000" + }, + { + "address": "0x140016f29", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0xd800" + }, + { + "address": "0x140016f2f", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ecx" + }, + { + "address": "0x140016f31", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x60], ecx" + }, + { + "address": "0x140016f35", + "size": 3, + "mnemonic": "shr", + "operands": "eax, 0xa" + }, + { + "address": "0x140016f38", + "size": 3, + "mnemonic": "dec", + "operands": "rsi" + }, + { + "address": "0x140016f3b", + "size": 4, + "mnemonic": "or", + "operands": "ax, r8w" + }, + { + "address": "0x140016f3f", + "size": 3, + "mnemonic": "mov", + "operands": "word ptr [rbx], ax" + }, + { + "address": "0x140016f42", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x3ff" + }, + { + "address": "0x140016f47", + "size": 3, + "mnemonic": "and", + "operands": "cx, ax" + }, + { + "address": "0x140016f4a", + "size": 4, + "mnemonic": "add", + "operands": "rbx, 2" + }, + { + "address": "0x140016f4e", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0xdc00" + }, + { + "address": "0x140016f53", + "size": 3, + "mnemonic": "or", + "operands": "cx, ax" + }, + { + "address": "0x140016f56", + "size": 3, + "mnemonic": "mov", + "operands": "word ptr [rbx], cx" + }, + { + "address": "0x140016f59", + "size": 3, + "mnemonic": "add", + "operands": "rdi, rdx" + }, + { + "address": "0x140016f5c", + "size": 4, + "mnemonic": "add", + "operands": "rbx, 2" + }, + { + "address": "0x140016f60", + "size": 4, + "mnemonic": "sub", + "operands": "rsi, 1" + }, + { + "address": "0x140016f64", + "size": 6, + "mnemonic": "jne", + "operands": "0x140016ebf" + }, + { + "address": "0x140016f6a", + "size": 3, + "mnemonic": "sub", + "operands": "rbx, rbp" + }, + { + "address": "0x140016f6d", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [r14], rdi" + }, + { + "address": "0x140016f70", + "size": 3, + "mnemonic": "sar", + "operands": "rbx, 1" + }, + { + "address": "0x140016f73", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140016f76", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14001700c" + } + ], + "successors": [ + "0x14001700c" + ] + } + ] + }, + { + "address": "0x1400170bc", + "name": "", + "blocks": [ + { + "address": "0x1400170bc", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400170bc", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x1400170c1", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x1400170c2", + "size": 6, + "mnemonic": "lea", + "operands": "eax, [rcx - 0xfde8]" + }, + { + "address": "0x1400170c8", + "size": 3, + "mnemonic": "mov", + "operands": "r11d, r9d" + }, + { + "address": "0x1400170cb", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x1400170ce", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r8" + }, + { + "address": "0x1400170d1", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0xdeac" + }, + { + "address": "0x1400170d6", + "size": 4, + "mnemonic": "setbe", + "operands": "r10b" + }, + { + "address": "0x1400170da", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x1400170dc", + "size": 2, + "mnemonic": "cmp", + "operands": "ecx, eax" + }, + { + "address": "0x1400170de", + "size": 2, + "mnemonic": "ja", + "operands": "0x140017121" + } + ], + "successors": [ + "0x140017121", + "0x1400170e0" + ] + }, + { + "address": "0x140017121", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017121", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ecx" + }, + { + "address": "0x140017123", + "size": 5, + "mnemonic": "sub", + "operands": "eax, 0xdead" + }, + { + "address": "0x140017128", + "size": 2, + "mnemonic": "je", + "operands": "0x14001715a" + } + ], + "successors": [ + "0x14001715a", + "0x14001712a" + ] + }, + { + "address": "0x1400170e0", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400170e0", + "size": 2, + "mnemonic": "je", + "operands": "0x14001715a" + } + ], + "successors": [ + "0x14001715a", + "0x1400170e2" + ] + }, + { + "address": "0x14001715a", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001715a", + "size": 2, + "mnemonic": "mov", + "operands": "edx, edi" + }, + { + "address": "0x14001715c", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x48]" + }, + { + "address": "0x140017161", + "size": 3, + "mnemonic": "test", + "operands": "r10b, r10b" + }, + { + "address": "0x140017164", + "size": 5, + "mnemonic": "mov", + "operands": "r9, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140017169", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rax" + }, + { + "address": "0x14001716c", + "size": 4, + "mnemonic": "cmovne", + "operands": "r8, rdi" + }, + { + "address": "0x140017170", + "size": 4, + "mnemonic": "cmovne", + "operands": "r9, rdi" + }, + { + "address": "0x140017174", + "size": 2, + "mnemonic": "je", + "operands": "0x14001717d" + } + ], + "successors": [ + "0x14001717d", + "0x140017176" + ] + }, + { + "address": "0x14001712a", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001712a", + "size": 3, + "mnemonic": "sub", + "operands": "eax, 1" + }, + { + "address": "0x14001712d", + "size": 2, + "mnemonic": "je", + "operands": "0x14001715a" + } + ], + "successors": [ + "0x14001715a", + "0x14001712f" + ] + }, + { + "address": "0x1400170e2", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400170e2", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0xc433" + }, + { + "address": "0x1400170e7", + "size": 2, + "mnemonic": "cmp", + "operands": "ecx, eax" + }, + { + "address": "0x1400170e9", + "size": 2, + "mnemonic": "ja", + "operands": "0x14001710a" + } + ], + "successors": [ + "0x14001710a", + "0x1400170eb" + ] + }, + { + "address": "0x14001717d", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001717d", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x48], r8" + }, + { + "address": "0x140017182", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rbx" + }, + { + "address": "0x140017185", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x40], r9" + }, + { + "address": "0x14001718a", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, r11d" + }, + { + "address": "0x14001718d", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x10]" + }, + { + "address": "0x140017192", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140017193", + "size": 7, + "mnemonic": "jmp", + "operands": "qword ptr [rip + 0x8e9e]" + } + ], + "successors": [ + "0x140020038" + ] + }, + { + "address": "0x140017176", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017176", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140017179", + "size": 2, + "mnemonic": "je", + "operands": "0x14001717d" + } + ], + "successors": [ + "0x14001717d", + "0x14001717b" + ] + }, + { + "address": "0x14001712f", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001712f", + "size": 3, + "mnemonic": "sub", + "operands": "eax, 1" + }, + { + "address": "0x140017132", + "size": 2, + "mnemonic": "je", + "operands": "0x14001715a" + } + ], + "successors": [ + "0x14001715a", + "0x140017134" + ] + }, + { + "address": "0x14001710a", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001710a", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ecx" + }, + { + "address": "0x14001710c", + "size": 5, + "mnemonic": "sub", + "operands": "eax, 0xc435" + }, + { + "address": "0x140017111", + "size": 2, + "mnemonic": "je", + "operands": "0x14001715a" + } + ], + "successors": [ + "0x14001715a", + "0x140017113" + ] + }, + { + "address": "0x1400170eb", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400170eb", + "size": 2, + "mnemonic": "je", + "operands": "0x14001715a" + } + ], + "successors": [ + "0x14001715a", + "0x1400170ed" + ] + }, + { + "address": "0x140020038", + "size": 0, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + ], + "successors": [ + ] + }, + { + "address": "0x14001717b", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001717b", + "size": 2, + "mnemonic": "mov", + "operands": "dword ptr [rax], edi" + }, + { + "address": "0x14001717d", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x48], r8" + }, + { + "address": "0x140017182", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rbx" + }, + { + "address": "0x140017185", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x40], r9" + }, + { + "address": "0x14001718a", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, r11d" + }, + { + "address": "0x14001718d", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x10]" + }, + { + "address": "0x140017192", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140017193", + "size": 7, + "mnemonic": "jmp", + "operands": "qword ptr [rip + 0x8e9e]" + } + ], + "successors": [ + "0x140020038" + ] + }, + { + "address": "0x140017134", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017134", + "size": 3, + "mnemonic": "sub", + "operands": "eax, 1" + }, + { + "address": "0x140017137", + "size": 2, + "mnemonic": "je", + "operands": "0x14001715a" + } + ], + "successors": [ + "0x14001715a", + "0x140017139" + ] + }, + { + "address": "0x140017113", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017113", + "size": 5, + "mnemonic": "sub", + "operands": "eax, 0x1263" + }, + { + "address": "0x140017118", + "size": 2, + "mnemonic": "je", + "operands": "0x14001715a" + } + ], + "successors": [ + "0x14001715a", + "0x14001711a" + ] + }, + { + "address": "0x1400170ed", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400170ed", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ecx" + }, + { + "address": "0x1400170ef", + "size": 3, + "mnemonic": "sub", + "operands": "eax, 0x2a" + }, + { + "address": "0x1400170f2", + "size": 2, + "mnemonic": "je", + "operands": "0x14001715a" + } + ], + "successors": [ + "0x14001715a", + "0x1400170f4" + ] + }, + { + "address": "0x140017139", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017139", + "size": 3, + "mnemonic": "sub", + "operands": "eax, 1" + }, + { + "address": "0x14001713c", + "size": 2, + "mnemonic": "je", + "operands": "0x14001715a" + } + ], + "successors": [ + "0x14001715a", + "0x14001713e" + ] + }, + { + "address": "0x14001711a", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001711a", + "size": 5, + "mnemonic": "sub", + "operands": "eax, 0x812" + }, + { + "address": "0x14001711f", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001714d" + } + ], + "successors": [ + "0x14001714d" + ] + }, + { + "address": "0x1400170f4", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400170f4", + "size": 5, + "mnemonic": "sub", + "operands": "eax, 0xc402" + }, + { + "address": "0x1400170f9", + "size": 2, + "mnemonic": "je", + "operands": "0x14001715a" + } + ], + "successors": [ + "0x14001715a", + "0x1400170fb" + ] + }, + { + "address": "0x14001713e", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001713e", + "size": 3, + "mnemonic": "sub", + "operands": "eax, 1" + }, + { + "address": "0x140017141", + "size": 2, + "mnemonic": "je", + "operands": "0x14001715a" + } + ], + "successors": [ + "0x14001715a", + "0x140017143" + ] + }, + { + "address": "0x14001714d", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001714d", + "size": 2, + "mnemonic": "je", + "operands": "0x14001715a" + } + ], + "successors": [ + "0x14001715a", + "0x14001714f" + ] + }, + { + "address": "0x1400170fb", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400170fb", + "size": 3, + "mnemonic": "sub", + "operands": "eax, 1" + }, + { + "address": "0x1400170fe", + "size": 2, + "mnemonic": "je", + "operands": "0x14001715a" + } + ], + "successors": [ + "0x14001715a", + "0x140017100" + ] + }, + { + "address": "0x140017143", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017143", + "size": 3, + "mnemonic": "sub", + "operands": "eax, 1" + }, + { + "address": "0x140017146", + "size": 2, + "mnemonic": "je", + "operands": "0x14001715a" + } + ], + "successors": [ + "0x14001715a", + "0x140017148" + ] + }, + { + "address": "0x14001714f", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001714f", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x140017152", + "size": 2, + "mnemonic": "je", + "operands": "0x14001715a" + } + ], + "successors": [ + "0x14001715a", + "0x140017154" + ] + }, + { + "address": "0x140017100", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017100", + "size": 3, + "mnemonic": "sub", + "operands": "eax, 1" + }, + { + "address": "0x140017103", + "size": 2, + "mnemonic": "je", + "operands": "0x14001715a" + } + ], + "successors": [ + "0x14001715a", + "0x140017105" + ] + }, + { + "address": "0x140017148", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017148", + "size": 5, + "mnemonic": "sub", + "operands": "eax, 0x1f35" + }, + { + "address": "0x14001714d", + "size": 2, + "mnemonic": "je", + "operands": "0x14001715a" + } + ], + "successors": [ + "0x14001715a", + "0x14001714f" + ] + }, + { + "address": "0x140017154", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017154", + "size": 4, + "mnemonic": "btr", + "operands": "edx, 7" + }, + { + "address": "0x140017158", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001715c" + } + ], + "successors": [ + "0x14001715c" + ] + }, + { + "address": "0x140017105", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017105", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 3" + }, + { + "address": "0x140017108", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140017152" + } + ], + "successors": [ + "0x140017152" + ] + }, + { + "address": "0x14001715c", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001715c", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x48]" + }, + { + "address": "0x140017161", + "size": 3, + "mnemonic": "test", + "operands": "r10b, r10b" + }, + { + "address": "0x140017164", + "size": 5, + "mnemonic": "mov", + "operands": "r9, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140017169", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rax" + }, + { + "address": "0x14001716c", + "size": 4, + "mnemonic": "cmovne", + "operands": "r8, rdi" + }, + { + "address": "0x140017170", + "size": 4, + "mnemonic": "cmovne", + "operands": "r9, rdi" + }, + { + "address": "0x140017174", + "size": 2, + "mnemonic": "je", + "operands": "0x14001717d" + } + ], + "successors": [ + "0x14001717d", + "0x140017176" + ] + }, + { + "address": "0x140017152", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017152", + "size": 2, + "mnemonic": "je", + "operands": "0x14001715a" + } + ], + "successors": [ + "0x14001715a", + "0x140017154" + ] + } + ] + }, + { + "address": "0x140012934", + "name": "", + "blocks": [ + { + "address": "0x140012934", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140012934", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x140012938", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001293b", + "size": 2, + "mnemonic": "jne", + "operands": "0x140012952" + }, + { + "address": "0x14001293d", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x140012942", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0x16" + }, + { + "address": "0x140012948", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afb4" + }, + { + "address": "0x14001294d", + "size": 3, + "mnemonic": "or", + "operands": "eax, 0xffffffff" + }, + { + "address": "0x140012950", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140012956" + } + ], + "successors": [ + "0x140012956" + ] + }, + { + "address": "0x140012956", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140012956", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14001295a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140013a8c", + "name": "", + "blocks": [ + { + "address": "0x140013a8c", + "size": 22, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140013a8c", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsp" + }, + { + "address": "0x140013a8f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x10], rbx" + }, + { + "address": "0x140013a93", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 8], rcx" + }, + { + "address": "0x140013a97", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140013a98", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x140013a9c", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x140013a9f", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140013aa2", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140013aa5", + "size": 2, + "mnemonic": "jne", + "operands": "0x140013ad6" + }, + { + "address": "0x140013aa7", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rdx + 0x30], 1" + }, + { + "address": "0x140013aab", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rdx + 0x2c], 0x16" + }, + { + "address": "0x140013ab2", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax - 0x10], rdx" + }, + { + "address": "0x140013ab6", + "size": 4, + "mnemonic": "and", + "operands": "qword ptr [rax - 0x18], rcx" + }, + { + "address": "0x140013aba", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x140013abd", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x140013ac0", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140013ac2", + "size": 5, + "mnemonic": "call", + "operands": "0x14000aefc" + }, + { + "address": "0x140013ac7", + "size": 4, + "mnemonic": "or", + "operands": "rax, 0xffffffffffffffff" + }, + { + "address": "0x140013acb", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x48]" + }, + { + "address": "0x140013ad0", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140013ad4", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140013ad5", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000d854", + "name": "", + "blocks": [ + { + "address": "0x14000d854", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000d854", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000d858", + "size": 5, + "mnemonic": "call", + "operands": "0x140011924" + }, + { + "address": "0x14000d85d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x14000d860", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x23989]" + }, + { + "address": "0x14000d867", + "size": 4, + "mnemonic": "add", + "operands": "rax, 0x24" + }, + { + "address": "0x14000d86b", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14000d86e", + "size": 4, + "mnemonic": "cmove", + "operands": "rax, rdx" + }, + { + "address": "0x14000d872", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000d876", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140014d20", + "name": "", + "blocks": [ + { + "address": "0x140014d20", + "size": 27, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140014d20", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rbx" + }, + { + "address": "0x140014d25", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rdx" + }, + { + "address": "0x140014d2a", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 8], ecx" + }, + { + "address": "0x140014d2e", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140014d2f", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140014d31", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140014d33", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140014d35", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140014d37", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x140014d3b", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r9" + }, + { + "address": "0x140014d3e", + "size": 3, + "mnemonic": "mov", + "operands": "r13d, r8d" + }, + { + "address": "0x140014d41", + "size": 3, + "mnemonic": "movsxd", + "operands": "rsi, ecx" + }, + { + "address": "0x140014d44", + "size": 3, + "mnemonic": "cmp", + "operands": "esi, -2" + }, + { + "address": "0x140014d47", + "size": 2, + "mnemonic": "jne", + "operands": "0x140014d77" + }, + { + "address": "0x140014d49", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [r9 + 0x38], 1" + }, + { + "address": "0x140014d4e", + "size": 5, + "mnemonic": "and", + "operands": "dword ptr [r9 + 0x34], 0" + }, + { + "address": "0x140014d53", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [r9 + 0x30], 1" + }, + { + "address": "0x140014d58", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [r9 + 0x2c], 9" + }, + { + "address": "0x140014d60", + "size": 4, + "mnemonic": "or", + "operands": "rax, 0xffffffffffffffff" + }, + { + "address": "0x140014d64", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140014d69", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140014d6d", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140014d6f", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140014d71", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140014d73", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140014d75", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140014d76", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140014e40", + "name": "", + "blocks": [ + { + "address": "0x140014e40", + "size": 17, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140014e40", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140014e45", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x140014e4a", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x140014e4f", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140014e50", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x140014e54", + "size": 3, + "mnemonic": "movsxd", + "operands": "rdi, ecx" + }, + { + "address": "0x140014e57", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r9" + }, + { + "address": "0x140014e5a", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, edi" + }, + { + "address": "0x140014e5c", + "size": 3, + "mnemonic": "mov", + "operands": "esi, r8d" + }, + { + "address": "0x140014e5f", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rdx" + }, + { + "address": "0x140014e62", + "size": 5, + "mnemonic": "call", + "operands": "0x14001949c" + }, + { + "address": "0x140014e67", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, -1" + }, + { + "address": "0x140014e6b", + "size": 2, + "mnemonic": "jne", + "operands": "0x140014e7e" + }, + { + "address": "0x140014e6d", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbx + 0x30], 1" + }, + { + "address": "0x140014e71", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 0x2c], 9" + }, + { + "address": "0x140014e78", + "size": 4, + "mnemonic": "or", + "operands": "rax, 0xffffffffffffffff" + }, + { + "address": "0x140014e7c", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140014eda" + } + ], + "successors": [ + "0x140014eda" + ] + }, + { + "address": "0x140014eda", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140014eda", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140014edf", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x140014ee4", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x140014ee9", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140014eed", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140014eee", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140015260", + "name": "", + "blocks": [ + { + "address": "0x140015260", + "size": 17, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015260", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140015265", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x14001526a", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x14001526f", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140015270", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140015272", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140015274", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x140015278", + "size": 2, + "mnemonic": "xor", + "operands": "ebx, ebx" + }, + { + "address": "0x14001527a", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r9" + }, + { + "address": "0x14001527d", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, r8" + }, + { + "address": "0x140015280", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rdx" + }, + { + "address": "0x140015283", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rcx" + }, + { + "address": "0x140015286", + "size": 3, + "mnemonic": "mov", + "operands": "r12d, ebx" + }, + { + "address": "0x140015289", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14001528c", + "size": 2, + "mnemonic": "jne", + "operands": "0x140015295" + }, + { + "address": "0x14001528e", + "size": 3, + "mnemonic": "test", + "operands": "r8, r8" + }, + { + "address": "0x140015291", + "size": 2, + "mnemonic": "je", + "operands": "0x1400152ce" + } + ], + "successors": [ + "0x1400152ce", + "0x140015293" + ] + }, + { + "address": "0x1400152ce", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400152ce", + "size": 3, + "mnemonic": "test", + "operands": "r14, r14" + }, + { + "address": "0x1400152d1", + "size": 2, + "mnemonic": "je", + "operands": "0x1400152d6" + } + ], + "successors": [ + "0x1400152d6", + "0x1400152d3" + ] + }, + { + "address": "0x140015293", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015293", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001529a" + } + ], + "successors": [ + "0x14001529a" + ] + }, + { + "address": "0x1400152d6", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400152d6", + "size": 5, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsp + 0x70]" + }, + { + "address": "0x1400152db", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x78]" + }, + { + "address": "0x1400152e0", + "size": 3, + "mnemonic": "cmp", + "operands": "r8, rbp" + }, + { + "address": "0x1400152e3", + "size": 4, + "mnemonic": "cmova", + "operands": "r8, rbp" + }, + { + "address": "0x1400152e7", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x7fffffff" + }, + { + "address": "0x1400152ee", + "size": 2, + "mnemonic": "jbe", + "operands": "0x1400152f7" + }, + { + "address": "0x1400152f0", + "size": 5, + "mnemonic": "mov", + "operands": "esi, 0x16" + }, + { + "address": "0x1400152f5", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001533c" + } + ], + "successors": [ + "0x14001533c" + ] + }, + { + "address": "0x1400152d3", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400152d3", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rcx], rbx" + }, + { + "address": "0x1400152d6", + "size": 5, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsp + 0x70]" + }, + { + "address": "0x1400152db", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x78]" + }, + { + "address": "0x1400152e0", + "size": 3, + "mnemonic": "cmp", + "operands": "r8, rbp" + }, + { + "address": "0x1400152e3", + "size": 4, + "mnemonic": "cmova", + "operands": "r8, rbp" + }, + { + "address": "0x1400152e7", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x7fffffff" + }, + { + "address": "0x1400152ee", + "size": 2, + "mnemonic": "jbe", + "operands": "0x1400152f7" + }, + { + "address": "0x1400152f0", + "size": 5, + "mnemonic": "mov", + "operands": "esi, 0x16" + }, + { + "address": "0x1400152f5", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001533c" + } + ], + "successors": [ + "0x14001533c" + ] + }, + { + "address": "0x14001529a", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001529a", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x78]" + }, + { + "address": "0x14001529f", + "size": 5, + "mnemonic": "mov", + "operands": "esi, 0x16" + }, + { + "address": "0x1400152a4", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x1400152a9", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rax + 0x30], 1" + }, + { + "address": "0x1400152ad", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x2c], esi" + }, + { + "address": "0x1400152b0", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x1400152b3", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rbx" + }, + { + "address": "0x1400152b8", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x1400152bb", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x1400152bd", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x1400152bf", + "size": 5, + "mnemonic": "call", + "operands": "0x14000aefc" + }, + { + "address": "0x1400152c4", + "size": 2, + "mnemonic": "mov", + "operands": "eax, esi" + }, + { + "address": "0x1400152c6", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140015366" + } + ], + "successors": [ + "0x140015366" + ] + }, + { + "address": "0x14001533c", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001533c", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rdi + 0x2c], esi" + }, + { + "address": "0x14001533f", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rdi + 0x30], 1" + }, + { + "address": "0x140015343", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rdi" + }, + { + "address": "0x140015348", + "size": 5, + "mnemonic": "jmp", + "operands": "0x1400152b0" + } + ], + "successors": [ + "0x1400152b0" + ] + }, + { + "address": "0x140015366", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140015366", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14001536b", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x58]" + }, + { + "address": "0x140015370", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x60]" + }, + { + "address": "0x140015375", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140015379", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001537b", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14001537d", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001537e", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400152b0", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400152b0", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x1400152b3", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rbx" + }, + { + "address": "0x1400152b8", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x1400152bb", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x1400152bd", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x1400152bf", + "size": 5, + "mnemonic": "call", + "operands": "0x14000aefc" + }, + { + "address": "0x1400152c4", + "size": 2, + "mnemonic": "mov", + "operands": "eax, esi" + }, + { + "address": "0x1400152c6", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140015366" + } + ], + "successors": [ + "0x140015366" + ] + } + ] + }, + { + "address": "0x140015620", + "name": "", + "blocks": [ + { + "address": "0x140015620", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015620", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140015625", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x14001562a", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x14001562f", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140015630", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140015632", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140015634", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x140015638", + "size": 2, + "mnemonic": "xor", + "operands": "ebx, ebx" + }, + { + "address": "0x14001563a", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r9" + }, + { + "address": "0x14001563d", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, r8" + }, + { + "address": "0x140015640", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rdx" + }, + { + "address": "0x140015643", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rcx" + }, + { + "address": "0x140015646", + "size": 3, + "mnemonic": "mov", + "operands": "r12d, ebx" + }, + { + "address": "0x140015649", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14001564c", + "size": 2, + "mnemonic": "je", + "operands": "0x14001567e" + } + ], + "successors": [ + "0x14001567e", + "0x14001564e" + ] + }, + { + "address": "0x14001567e", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001567e", + "size": 3, + "mnemonic": "test", + "operands": "rbp, rbp" + }, + { + "address": "0x140015681", + "size": 2, + "mnemonic": "je", + "operands": "0x140015655" + } + ], + "successors": [ + "0x140015655", + "0x140015683" + ] + }, + { + "address": "0x14001564e", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001564e", + "size": 3, + "mnemonic": "test", + "operands": "r8, r8" + }, + { + "address": "0x140015651", + "size": 2, + "mnemonic": "je", + "operands": "0x140015683" + } + ], + "successors": [ + "0x140015683", + "0x140015653" + ] + }, + { + "address": "0x140015655", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015655", + "size": 3, + "mnemonic": "test", + "operands": "r14, r14" + }, + { + "address": "0x140015658", + "size": 2, + "mnemonic": "je", + "operands": "0x14001565d" + } + ], + "successors": [ + "0x14001565d", + "0x14001565a" + ] + }, + { + "address": "0x140015683", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015683", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x78]" + }, + { + "address": "0x140015688", + "size": 5, + "mnemonic": "mov", + "operands": "esi, 0x16" + }, + { + "address": "0x14001568d", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x140015692", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rax + 0x30], 1" + }, + { + "address": "0x140015696", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x2c], esi" + }, + { + "address": "0x140015699", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x14001569c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rbx" + }, + { + "address": "0x1400156a1", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x1400156a4", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x1400156a6", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x1400156a8", + "size": 5, + "mnemonic": "call", + "operands": "0x14000aefc" + }, + { + "address": "0x1400156ad", + "size": 2, + "mnemonic": "mov", + "operands": "eax, esi" + }, + { + "address": "0x1400156af", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001571a" + } + ], + "successors": [ + "0x14001571a" + ] + }, + { + "address": "0x140015653", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015653", + "size": 2, + "mnemonic": "mov", + "operands": "byte ptr [rdx], bl" + }, + { + "address": "0x140015655", + "size": 3, + "mnemonic": "test", + "operands": "r14, r14" + }, + { + "address": "0x140015658", + "size": 2, + "mnemonic": "je", + "operands": "0x14001565d" + } + ], + "successors": [ + "0x14001565d", + "0x14001565a" + ] + }, + { + "address": "0x14001565d", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001565d", + "size": 5, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140015662", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x78]" + }, + { + "address": "0x140015667", + "size": 3, + "mnemonic": "cmp", + "operands": "r8, rbp" + }, + { + "address": "0x14001566a", + "size": 4, + "mnemonic": "cmova", + "operands": "r8, rbp" + }, + { + "address": "0x14001566e", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x7fffffff" + }, + { + "address": "0x140015675", + "size": 2, + "mnemonic": "jbe", + "operands": "0x1400156b1" + }, + { + "address": "0x140015677", + "size": 5, + "mnemonic": "mov", + "operands": "esi, 0x16" + }, + { + "address": "0x14001567c", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400156f4" + } + ], + "successors": [ + "0x1400156f4" + ] + }, + { + "address": "0x14001565a", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001565a", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rcx], rbx" + }, + { + "address": "0x14001565d", + "size": 5, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140015662", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x78]" + }, + { + "address": "0x140015667", + "size": 3, + "mnemonic": "cmp", + "operands": "r8, rbp" + }, + { + "address": "0x14001566a", + "size": 4, + "mnemonic": "cmova", + "operands": "r8, rbp" + }, + { + "address": "0x14001566e", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x7fffffff" + }, + { + "address": "0x140015675", + "size": 2, + "mnemonic": "jbe", + "operands": "0x1400156b1" + }, + { + "address": "0x140015677", + "size": 5, + "mnemonic": "mov", + "operands": "esi, 0x16" + }, + { + "address": "0x14001567c", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400156f4" + } + ], + "successors": [ + "0x1400156f4" + ] + }, + { + "address": "0x14001571a", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001571a", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14001571f", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x58]" + }, + { + "address": "0x140015724", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x60]" + }, + { + "address": "0x140015729", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001572d", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001572f", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140015731", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140015732", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400156f4", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400156f4", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rdi + 0x2c], esi" + }, + { + "address": "0x1400156f7", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rdi + 0x30], 1" + }, + { + "address": "0x1400156fb", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rdi" + }, + { + "address": "0x140015700", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140015699" + } + ], + "successors": [ + "0x140015699" + ] + }, + { + "address": "0x140015699", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015699", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x14001569c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rbx" + }, + { + "address": "0x1400156a1", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x1400156a4", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x1400156a6", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x1400156a8", + "size": 5, + "mnemonic": "call", + "operands": "0x14000aefc" + }, + { + "address": "0x1400156ad", + "size": 2, + "mnemonic": "mov", + "operands": "eax, esi" + }, + { + "address": "0x1400156af", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001571a" + } + ], + "successors": [ + "0x14001571a" + ] + } + ] + }, + { + "address": "0x14000d89c", + "name": "", + "blocks": [ + { + "address": "0x14000d89c", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d89c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000d8a1", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rsi" + }, + { + "address": "0x14000d8a6", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000d8a7", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000d8ab", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rcx + 0x18], 0" + }, + { + "address": "0x14000d8af", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x14000d8b2", + "size": 4, + "mnemonic": "lea", + "operands": "rsi, [rcx + 8]" + }, + { + "address": "0x14000d8b6", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14000d8b9", + "size": 2, + "mnemonic": "je", + "operands": "0x14000d8c0" + } + ], + "successors": [ + "0x14000d8c0", + "0x14000d8bb" + ] + }, + { + "address": "0x14000d8c0", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d8c0", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x25929], 0" + }, + { + "address": "0x14000d8c7", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000d8d6" + }, + { + "address": "0x14000d8c9", + "size": 7, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rip + 0x23b58]" + }, + { + "address": "0x14000d8d0", + "size": 4, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rsi], xmm0" + }, + { + "address": "0x14000d8d4", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000d924" + } + ], + "successors": [ + "0x14000d924" + ] + }, + { + "address": "0x14000d8bb", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d8bb", + "size": 3, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rdx]" + }, + { + "address": "0x14000d8be", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000d8d0" + } + ], + "successors": [ + "0x14000d8d0" + ] + }, + { + "address": "0x14000d924", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000d924", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000d929", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdi" + }, + { + "address": "0x14000d92c", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14000d931", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000d935", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000d936", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000d8d0", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d8d0", + "size": 4, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rsi], xmm0" + }, + { + "address": "0x14000d8d4", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000d924" + } + ], + "successors": [ + "0x14000d924" + ] + } + ] + }, + { + "address": "0x140011ff0", + "name": "", + "blocks": [ + { + "address": "0x140011ff0", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011ff0", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140011ff5", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x140011ffa", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x140011fff", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140012000", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x140012004", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x24045]" + }, + { + "address": "0x14001200b", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, r9d" + }, + { + "address": "0x14001200e", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r8" + }, + { + "address": "0x140012011", + "size": 2, + "mnemonic": "mov", + "operands": "esi, edx" + }, + { + "address": "0x140012013", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rcx" + }, + { + "address": "0x140012016", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, -1" + }, + { + "address": "0x14001201a", + "size": 2, + "mnemonic": "je", + "operands": "0x140012055" + } + ], + "successors": [ + "0x140012055", + "0x14001201c" + ] + }, + { + "address": "0x140012055", + "size": 14, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140012055", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140012057", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbp" + }, + { + "address": "0x14001205a", + "size": 5, + "mnemonic": "call", + "operands": "0x1400122e0" + }, + { + "address": "0x14001205f", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, eax" + }, + { + "address": "0x140012061", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, ebx" + }, + { + "address": "0x140012064", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rdi" + }, + { + "address": "0x140012067", + "size": 2, + "mnemonic": "mov", + "operands": "edx, esi" + }, + { + "address": "0x140012069", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xe159]" + }, + { + "address": "0x14001206f", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140012074", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x140012079", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14001207e", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140012082", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140012083", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001201c", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001201c", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001201f", + "size": 2, + "mnemonic": "jne", + "operands": "0x140012043" + }, + { + "address": "0x140012021", + "size": 7, + "mnemonic": "lea", + "operands": "r9, [rip + 0x148e8]" + }, + { + "address": "0x140012028", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip + 0x148d9]" + }, + { + "address": "0x14001202f", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x148da]" + }, + { + "address": "0x140012036", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rax + 0xa]" + }, + { + "address": "0x140012039", + "size": 5, + "mnemonic": "call", + "operands": "0x140011c00" + }, + { + "address": "0x14001203e", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140012041", + "size": 2, + "mnemonic": "je", + "operands": "0x140012055" + } + ], + "successors": [ + "0x140012055", + "0x140012043" + ] + }, + { + "address": "0x140012043", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140012043", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, ebx" + }, + { + "address": "0x140012046", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rdi" + }, + { + "address": "0x140012049", + "size": 2, + "mnemonic": "mov", + "operands": "edx, esi" + }, + { + "address": "0x14001204b", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbp" + }, + { + "address": "0x14001204e", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3a0" + }, + { + "address": "0x140012053", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001206f" + } + ], + "successors": [ + "0x14001206f" + ] + }, + { + "address": "0x14001206f", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001206f", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140012074", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x140012079", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14001207e", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140012082", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140012083", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140011a80", + "name": "", + "blocks": [ + { + "address": "0x140011a80", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011a80", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140011a82", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140011a86", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rdx" + }, + { + "address": "0x140011a89", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140011a8c", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140011a8f", + "size": 2, + "mnemonic": "je", + "operands": "0x140011a9f" + } + ], + "successors": [ + "0x140011a9f", + "0x140011a91" + ] + }, + { + "address": "0x140011a9f", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011a9f", + "size": 4, + "mnemonic": "imul", + "operands": "rbx, r8" + }, + { + "address": "0x140011aa3", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 1" + }, + { + "address": "0x140011aa8", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x140011aab", + "size": 4, + "mnemonic": "cmove", + "operands": "rbx, rax" + }, + { + "address": "0x140011aaf", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140011ac6" + } + ], + "successors": [ + "0x140011ac6" + ] + }, + { + "address": "0x140011a91", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011a91", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140011a93", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rdx - 0x20]" + }, + { + "address": "0x140011a97", + "size": 3, + "mnemonic": "div", + "operands": "rbx" + }, + { + "address": "0x140011a9a", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, r8" + }, + { + "address": "0x140011a9d", + "size": 2, + "mnemonic": "jb", + "operands": "0x140011ae2" + } + ], + "successors": [ + "0x140011ae2", + "0x140011a9f" + ] + }, + { + "address": "0x140011ac6", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011ac6", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rip + 0x21d8b]" + }, + { + "address": "0x140011acd", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rbx" + }, + { + "address": "0x140011ad0", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 8" + }, + { + "address": "0x140011ad5", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xe6a5]" + }, + { + "address": "0x140011adb", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140011ade", + "size": 2, + "mnemonic": "je", + "operands": "0x140011ab1" + } + ], + "successors": [ + "0x140011ab1", + "0x140011ae0" + ] + }, + { + "address": "0x140011ae2", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140011ae2", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x140011ae7", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0xc" + }, + { + "address": "0x140011aed", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140011aef", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140011af3", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140011af4", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140011ab1", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011ab1", + "size": 5, + "mnemonic": "call", + "operands": "0x1400105b0" + }, + { + "address": "0x140011ab6", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140011ab8", + "size": 2, + "mnemonic": "je", + "operands": "0x140011ae2" + } + ], + "successors": [ + "0x140011ae2", + "0x140011aba" + ] + }, + { + "address": "0x140011ae0", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011ae0", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140011aef" + } + ], + "successors": [ + "0x140011aef" + ] + }, + { + "address": "0x140011aba", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011aba", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140011abd", + "size": 5, + "mnemonic": "call", + "operands": "0x14000deb0" + }, + { + "address": "0x140011ac2", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140011ac4", + "size": 2, + "mnemonic": "je", + "operands": "0x140011ae2" + } + ], + "successors": [ + "0x140011ae2", + "0x140011ac6" + ] + }, + { + "address": "0x140011aef", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140011aef", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140011af3", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140011af4", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001c3c0", + "name": "", + "blocks": [ + { + "address": "0x14001c3c0", + "size": 18, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001c3c0", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14001c3c5", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001c3c6", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001c3ca", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r9" + }, + { + "address": "0x14001c3cd", + "size": 3, + "mnemonic": "mov", + "operands": "r10, r8" + }, + { + "address": "0x14001c3d0", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdx" + }, + { + "address": "0x14001c3d3", + "size": 3, + "mnemonic": "mov", + "operands": "r11, rcx" + }, + { + "address": "0x14001c3d6", + "size": 3, + "mnemonic": "test", + "operands": "r9, r9" + }, + { + "address": "0x14001c3d9", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001c3f2" + }, + { + "address": "0x14001c3db", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001c3de", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001c3f7" + }, + { + "address": "0x14001c3e0", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14001c3e3", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001c419" + }, + { + "address": "0x14001c3e5", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001c3e7", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001c3ec", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001c3f0", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001c3f1", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001702c", + "name": "", + "blocks": [ + { + "address": "0x14001702c", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001702c", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0xdeac" + }, + { + "address": "0x140017031", + "size": 2, + "mnemonic": "cmp", + "operands": "ecx, eax" + }, + { + "address": "0x140017033", + "size": 2, + "mnemonic": "ja", + "operands": "0x140017084" + } + ], + "successors": [ + "0x140017084", + "0x140017035" + ] + }, + { + "address": "0x140017084", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017084", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ecx" + }, + { + "address": "0x140017086", + "size": 5, + "mnemonic": "sub", + "operands": "eax, 0xdead" + }, + { + "address": "0x14001708b", + "size": 2, + "mnemonic": "je", + "operands": "0x14001707b" + } + ], + "successors": [ + "0x14001707b", + "0x14001708d" + ] + }, + { + "address": "0x140017035", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017035", + "size": 2, + "mnemonic": "je", + "operands": "0x14001707b" + } + ], + "successors": [ + "0x14001707b", + "0x140017037" + ] + }, + { + "address": "0x14001707b", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001707b", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14001707d", + "size": 7, + "mnemonic": "jmp", + "operands": "qword ptr [rip + 0x8fac]" + } + ], + "successors": [ + "0x140020030" + ] + }, + { + "address": "0x14001708d", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001708d", + "size": 3, + "mnemonic": "sub", + "operands": "eax, 1" + }, + { + "address": "0x140017090", + "size": 2, + "mnemonic": "je", + "operands": "0x14001707b" + } + ], + "successors": [ + "0x14001707b", + "0x140017092" + ] + }, + { + "address": "0x140017037", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017037", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0xc433" + }, + { + "address": "0x14001703c", + "size": 2, + "mnemonic": "cmp", + "operands": "ecx, eax" + }, + { + "address": "0x14001703e", + "size": 2, + "mnemonic": "ja", + "operands": "0x14001705f" + } + ], + "successors": [ + "0x14001705f", + "0x140017040" + ] + }, + { + "address": "0x140020030", + "size": 0, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + ], + "successors": [ + ] + }, + { + "address": "0x140017092", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017092", + "size": 3, + "mnemonic": "sub", + "operands": "eax, 1" + }, + { + "address": "0x140017095", + "size": 2, + "mnemonic": "je", + "operands": "0x14001707b" + } + ], + "successors": [ + "0x14001707b", + "0x140017097" + ] + }, + { + "address": "0x14001705f", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001705f", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ecx" + }, + { + "address": "0x140017061", + "size": 5, + "mnemonic": "sub", + "operands": "eax, 0xc435" + }, + { + "address": "0x140017066", + "size": 2, + "mnemonic": "je", + "operands": "0x14001707b" + } + ], + "successors": [ + "0x14001707b", + "0x140017068" + ] + }, + { + "address": "0x140017040", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017040", + "size": 2, + "mnemonic": "je", + "operands": "0x14001707b" + } + ], + "successors": [ + "0x14001707b", + "0x140017042" + ] + }, + { + "address": "0x140017097", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017097", + "size": 3, + "mnemonic": "sub", + "operands": "eax, 1" + }, + { + "address": "0x14001709a", + "size": 2, + "mnemonic": "je", + "operands": "0x14001707b" + } + ], + "successors": [ + "0x14001707b", + "0x14001709c" + ] + }, + { + "address": "0x140017068", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017068", + "size": 5, + "mnemonic": "sub", + "operands": "eax, 0x1263" + }, + { + "address": "0x14001706d", + "size": 2, + "mnemonic": "je", + "operands": "0x1400170b7" + } + ], + "successors": [ + "0x1400170b7", + "0x14001706f" + ] + }, + { + "address": "0x140017042", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017042", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ecx" + }, + { + "address": "0x140017044", + "size": 3, + "mnemonic": "sub", + "operands": "eax, 0x2a" + }, + { + "address": "0x140017047", + "size": 2, + "mnemonic": "je", + "operands": "0x14001707b" + } + ], + "successors": [ + "0x14001707b", + "0x140017049" + ] + }, + { + "address": "0x14001709c", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001709c", + "size": 3, + "mnemonic": "sub", + "operands": "eax, 1" + }, + { + "address": "0x14001709f", + "size": 2, + "mnemonic": "je", + "operands": "0x14001707b" + } + ], + "successors": [ + "0x14001707b", + "0x1400170a1" + ] + }, + { + "address": "0x1400170b7", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400170b7", + "size": 3, + "mnemonic": "and", + "operands": "edx, 8" + }, + { + "address": "0x1400170ba", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001707d" + } + ], + "successors": [ + "0x14001707d" + ] + }, + { + "address": "0x14001706f", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001706f", + "size": 5, + "mnemonic": "sub", + "operands": "eax, 0x812" + }, + { + "address": "0x140017074", + "size": 2, + "mnemonic": "je", + "operands": "0x14001707b" + } + ], + "successors": [ + "0x14001707b", + "0x140017076" + ] + }, + { + "address": "0x140017049", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017049", + "size": 5, + "mnemonic": "sub", + "operands": "eax, 0xc402" + }, + { + "address": "0x14001704e", + "size": 2, + "mnemonic": "je", + "operands": "0x14001707b" + } + ], + "successors": [ + "0x14001707b", + "0x140017050" + ] + }, + { + "address": "0x1400170a1", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400170a1", + "size": 3, + "mnemonic": "sub", + "operands": "eax, 1" + }, + { + "address": "0x1400170a4", + "size": 2, + "mnemonic": "je", + "operands": "0x14001707b" + } + ], + "successors": [ + "0x14001707b", + "0x1400170a6" + ] + }, + { + "address": "0x14001707d", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001707d", + "size": 7, + "mnemonic": "jmp", + "operands": "qword ptr [rip + 0x8fac]" + } + ], + "successors": [ + "0x140020030" + ] + }, + { + "address": "0x140017076", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017076", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x140017079", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001707d" + }, + { + "address": "0x14001707b", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14001707d", + "size": 7, + "mnemonic": "jmp", + "operands": "qword ptr [rip + 0x8fac]" + } + ], + "successors": [ + "0x140020030" + ] + }, + { + "address": "0x140017050", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017050", + "size": 3, + "mnemonic": "sub", + "operands": "eax, 1" + }, + { + "address": "0x140017053", + "size": 2, + "mnemonic": "je", + "operands": "0x14001707b" + } + ], + "successors": [ + "0x14001707b", + "0x140017055" + ] + }, + { + "address": "0x1400170a6", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400170a6", + "size": 3, + "mnemonic": "sub", + "operands": "eax, 1" + }, + { + "address": "0x1400170a9", + "size": 2, + "mnemonic": "je", + "operands": "0x14001707b" + } + ], + "successors": [ + "0x14001707b", + "0x1400170ab" + ] + }, + { + "address": "0x140017055", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017055", + "size": 3, + "mnemonic": "sub", + "operands": "eax, 1" + }, + { + "address": "0x140017058", + "size": 2, + "mnemonic": "je", + "operands": "0x14001707b" + } + ], + "successors": [ + "0x14001707b", + "0x14001705a" + ] + }, + { + "address": "0x1400170ab", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400170ab", + "size": 5, + "mnemonic": "sub", + "operands": "eax, 0x1f35" + }, + { + "address": "0x1400170b0", + "size": 2, + "mnemonic": "je", + "operands": "0x14001707b" + } + ], + "successors": [ + "0x14001707b", + "0x1400170b2" + ] + }, + { + "address": "0x14001705a", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001705a", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 3" + }, + { + "address": "0x14001705d", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140017079" + } + ], + "successors": [ + "0x140017079" + ] + }, + { + "address": "0x1400170b2", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400170b2", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x1400170b5", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001707d" + }, + { + "address": "0x1400170b7", + "size": 3, + "mnemonic": "and", + "operands": "edx, 8" + }, + { + "address": "0x1400170ba", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001707d" + } + ], + "successors": [ + "0x14001707d" + ] + }, + { + "address": "0x140017079", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017079", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001707d" + }, + { + "address": "0x14001707b", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14001707d", + "size": 7, + "mnemonic": "jmp", + "operands": "qword ptr [rip + 0x8fac]" + } + ], + "successors": [ + "0x140020030" + ] + } + ] + }, + { + "address": "0x1400121ec", + "name": "", + "blocks": [ + { + "address": "0x1400121ec", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400121ec", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x1400121f1", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x1400121f6", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x1400121fb", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x1400121fc", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x50" + }, + { + "address": "0x140012200", + "size": 7, + "mnemonic": "mov", + "operands": "r10, qword ptr [rip + 0x23e89]" + }, + { + "address": "0x140012207", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, r9d" + }, + { + "address": "0x14001220a", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r8" + }, + { + "address": "0x14001220d", + "size": 2, + "mnemonic": "mov", + "operands": "esi, edx" + }, + { + "address": "0x14001220f", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rcx" + }, + { + "address": "0x140012212", + "size": 4, + "mnemonic": "cmp", + "operands": "r10, -1" + }, + { + "address": "0x140012216", + "size": 2, + "mnemonic": "je", + "operands": "0x140012297" + } + ], + "successors": [ + "0x140012297", + "0x140012218" + ] + }, + { + "address": "0x140012297", + "size": 18, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140012297", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140012299", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbp" + }, + { + "address": "0x14001229c", + "size": 5, + "mnemonic": "call", + "operands": "0x1400122e0" + }, + { + "address": "0x1400122a1", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, eax" + }, + { + "address": "0x1400122a3", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, ebx" + }, + { + "address": "0x1400122a6", + "size": 7, + "mnemonic": "mov", + "operands": "eax, dword ptr [rsp + 0x88]" + }, + { + "address": "0x1400122ad", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rdi" + }, + { + "address": "0x1400122b0", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], eax" + }, + { + "address": "0x1400122b4", + "size": 2, + "mnemonic": "mov", + "operands": "edx, esi" + }, + { + "address": "0x1400122b6", + "size": 8, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x80]" + }, + { + "address": "0x1400122be", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x1400122c3", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xdef7]" + }, + { + "address": "0x1400122c9", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x60]" + }, + { + "address": "0x1400122ce", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x68]" + }, + { + "address": "0x1400122d3", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x70]" + }, + { + "address": "0x1400122d8", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x50" + }, + { + "address": "0x1400122dc", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400122dd", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140012218", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140012218", + "size": 3, + "mnemonic": "test", + "operands": "r10, r10" + }, + { + "address": "0x14001221b", + "size": 2, + "mnemonic": "jne", + "operands": "0x140012243" + }, + { + "address": "0x14001221d", + "size": 7, + "mnemonic": "lea", + "operands": "r9, [rip + 0x14764]" + }, + { + "address": "0x140012224", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip + 0x14755]" + }, + { + "address": "0x14001222b", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x14756]" + }, + { + "address": "0x140012232", + "size": 4, + "mnemonic": "lea", + "operands": "ecx, [r10 + 0x12]" + }, + { + "address": "0x140012236", + "size": 5, + "mnemonic": "call", + "operands": "0x140011c00" + }, + { + "address": "0x14001223b", + "size": 3, + "mnemonic": "mov", + "operands": "r10, rax" + }, + { + "address": "0x14001223e", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140012241", + "size": 2, + "mnemonic": "je", + "operands": "0x140012297" + } + ], + "successors": [ + "0x140012297", + "0x140012243" + ] + }, + { + "address": "0x140012243", + "size": 17, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140012243", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0xa0]" + }, + { + "address": "0x14001224b", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, ebx" + }, + { + "address": "0x14001224e", + "size": 7, + "mnemonic": "mov", + "operands": "eax, dword ptr [rsp + 0x88]" + }, + { + "address": "0x140012255", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rdi" + }, + { + "address": "0x140012258", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x40], rcx" + }, + { + "address": "0x14001225d", + "size": 2, + "mnemonic": "mov", + "operands": "edx, esi" + }, + { + "address": "0x14001225f", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x98]" + }, + { + "address": "0x140012267", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], rcx" + }, + { + "address": "0x14001226c", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x90]" + }, + { + "address": "0x140012274", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rcx" + }, + { + "address": "0x140012279", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbp" + }, + { + "address": "0x14001227c", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], eax" + }, + { + "address": "0x140012280", + "size": 8, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x80]" + }, + { + "address": "0x140012288", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14001228d", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r10" + }, + { + "address": "0x140012290", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3a0" + }, + { + "address": "0x140012295", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400122c9" + } + ], + "successors": [ + "0x1400122c9" + ] + }, + { + "address": "0x1400122c9", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400122c9", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x60]" + }, + { + "address": "0x1400122ce", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x68]" + }, + { + "address": "0x1400122d3", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x70]" + }, + { + "address": "0x1400122d8", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x50" + }, + { + "address": "0x1400122dc", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400122dd", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140017a50", + "name": "", + "blocks": [ + { + "address": "0x140017a50", + "size": 35, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140017a50", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140017a55", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x140017a5a", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x140017a5f", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140017a60", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140017a62", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140017a64", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140017a66", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140017a68", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x140017a6c", + "size": 4, + "mnemonic": "or", + "operands": "rbp, 0xffffffffffffffff" + }, + { + "address": "0x140017a70", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, r9" + }, + { + "address": "0x140017a73", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x140017a75", + "size": 3, + "mnemonic": "mov", + "operands": "r14, r8" + }, + { + "address": "0x140017a78", + "size": 3, + "mnemonic": "mov", + "operands": "r13, rdx" + }, + { + "address": "0x140017a7b", + "size": 3, + "mnemonic": "mov", + "operands": "r12, rcx" + }, + { + "address": "0x140017a7e", + "size": 3, + "mnemonic": "inc", + "operands": "rbp" + }, + { + "address": "0x140017a81", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rcx + rbp], dil" + }, + { + "address": "0x140017a85", + "size": 2, + "mnemonic": "jne", + "operands": "0x140017a7e" + }, + { + "address": "0x140017a87", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 1" + }, + { + "address": "0x140017a8c", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r14" + }, + { + "address": "0x140017a8f", + "size": 3, + "mnemonic": "add", + "operands": "rbp, rdx" + }, + { + "address": "0x140017a92", + "size": 3, + "mnemonic": "not", + "operands": "rax" + }, + { + "address": "0x140017a95", + "size": 3, + "mnemonic": "cmp", + "operands": "rbp, rax" + }, + { + "address": "0x140017a98", + "size": 2, + "mnemonic": "jbe", + "operands": "0x140017aba" + }, + { + "address": "0x140017a9a", + "size": 3, + "mnemonic": "lea", + "operands": "eax, [rdx + 0xb]" + }, + { + "address": "0x140017a9d", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x60]" + }, + { + "address": "0x140017aa2", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x68]" + }, + { + "address": "0x140017aa7", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x70]" + }, + { + "address": "0x140017aac", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140017ab0", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140017ab2", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140017ab4", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140017ab6", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140017ab8", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140017ab9", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001cea8", + "name": "", + "blocks": [ + { + "address": "0x14001cea8", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001cea8", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x14001ceab", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14001ceb0" + } + ], + "successors": [ + "0x14001ceb0" + ] + }, + { + "address": "0x14001ceb0", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ceb0", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14001ceb5", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001ceb6", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x14001ceba", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdx" + }, + { + "address": "0x14001cebd", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x14001cec0", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001cec3", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001ced9" + }, + { + "address": "0x14001cec5", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x14001ceca", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0x16" + }, + { + "address": "0x14001ced0", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afb4" + }, + { + "address": "0x14001ced5", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001ced7", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001cf39" + } + ], + "successors": [ + "0x14001cf39" + ] + }, + { + "address": "0x14001cf39", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001cf39", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14001cf3e", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x40" + }, + { + "address": "0x14001cf42", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001cf43", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000d9d8", + "name": "", + "blocks": [ + { + "address": "0x14000d9d8", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d9d8", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsp" + }, + { + "address": "0x14000d9db", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 8], rbx" + }, + { + "address": "0x14000d9df", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x10], rbp" + }, + { + "address": "0x14000d9e3", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x18], rsi" + }, + { + "address": "0x14000d9e7", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x20], rdi" + }, + { + "address": "0x14000d9eb", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000d9ed", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000d9f1", + "size": 3, + "mnemonic": "xor", + "operands": "r14d, r14d" + }, + { + "address": "0x14000d9f4", + "size": 3, + "mnemonic": "mov", + "operands": "ebp, r9d" + }, + { + "address": "0x14000d9f7", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdx" + }, + { + "address": "0x14000d9fa", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x14000d9fd", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14000da00", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000da26" + }, + { + "address": "0x14000da02", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rdx + 0x28], r14b" + }, + { + "address": "0x14000da06", + "size": 2, + "mnemonic": "je", + "operands": "0x14000da15" + } + ], + "successors": [ + "0x14000da15", + "0x14000da08" + ] + }, + { + "address": "0x14000da15", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000da15", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x10], r14" + }, + { + "address": "0x14000da19", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x18], r14" + }, + { + "address": "0x14000da1d", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x20], r14" + }, + { + "address": "0x14000da21", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000db58" + } + ], + "successors": [ + "0x14000db58" + ] + }, + { + "address": "0x14000da08", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000da08", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdx + 0x10]" + }, + { + "address": "0x14000da0c", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14000da11", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbx + 0x28], r14b" + }, + { + "address": "0x14000da15", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x10], r14" + }, + { + "address": "0x14000da19", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x18], r14" + }, + { + "address": "0x14000da1d", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x20], r14" + }, + { + "address": "0x14000da21", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000db58" + } + ], + "successors": [ + "0x14000db58" + ] + }, + { + "address": "0x14000db58", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000db58", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000db5a", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14000db5f", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14000db64", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14000db69", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x58]" + }, + { + "address": "0x14000db6e", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000db72", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000db74", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000d808", + "name": "", + "blocks": [ + { + "address": "0x14000d808", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000d808", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x14000d80a", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000d80e", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, ecx" + }, + { + "address": "0x14000d810", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d854" + }, + { + "address": "0x14000d815", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x14000d817", + "size": 2, + "mnemonic": "mov", + "operands": "dword ptr [rax], ebx" + }, + { + "address": "0x14000d819", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d738" + }, + { + "address": "0x14000d81e", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, eax" + }, + { + "address": "0x14000d820", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x14000d825", + "size": 2, + "mnemonic": "mov", + "operands": "dword ptr [rax], ebx" + }, + { + "address": "0x14000d827", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000d82b", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000d82c", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140016514", + "name": "", + "blocks": [ + { + "address": "0x140016514", + "size": 27, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016514", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140016519", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rsi" + }, + { + "address": "0x14001651e", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001651f", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x70" + }, + { + "address": "0x140016523", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rdx" + }, + { + "address": "0x140016526", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r9" + }, + { + "address": "0x140016529", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rcx" + }, + { + "address": "0x14001652c", + "size": 3, + "mnemonic": "mov", + "operands": "edi, r8d" + }, + { + "address": "0x14001652f", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x50]" + }, + { + "address": "0x140016534", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d89c" + }, + { + "address": "0x140016539", + "size": 7, + "mnemonic": "mov", + "operands": "eax, dword ptr [rsp + 0xc0]" + }, + { + "address": "0x140016540", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x58]" + }, + { + "address": "0x140016545", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x40], eax" + }, + { + "address": "0x140016549", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rbx" + }, + { + "address": "0x14001654c", + "size": 7, + "mnemonic": "mov", + "operands": "eax, dword ptr [rsp + 0xb8]" + }, + { + "address": "0x140016553", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, edi" + }, + { + "address": "0x140016556", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x38], eax" + }, + { + "address": "0x14001655a", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x14001655d", + "size": 7, + "mnemonic": "mov", + "operands": "eax, dword ptr [rsp + 0xb0]" + }, + { + "address": "0x140016564", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x30], eax" + }, + { + "address": "0x140016568", + "size": 8, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0xa8]" + }, + { + "address": "0x140016570", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x140016575", + "size": 7, + "mnemonic": "mov", + "operands": "eax, dword ptr [rsp + 0xa0]" + }, + { + "address": "0x14001657c", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x20], eax" + }, + { + "address": "0x140016580", + "size": 5, + "mnemonic": "call", + "operands": "0x1400161e0" + }, + { + "address": "0x140016585", + "size": 5, + "mnemonic": "cmp", + "operands": "byte ptr [rsp + 0x68], 0" + }, + { + "address": "0x14001658a", + "size": 2, + "mnemonic": "je", + "operands": "0x140016598" + } + ], + "successors": [ + "0x140016598", + "0x14001658c" + ] + }, + { + "address": "0x140016598", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140016598", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x70]" + }, + { + "address": "0x14001659d", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x10]" + }, + { + "address": "0x1400165a1", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x18]" + }, + { + "address": "0x1400165a5", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x1400165a8", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400165a9", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001658c", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001658c", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x50]" + }, + { + "address": "0x140016591", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rcx + 0x3a8], 0xfffffffd" + }, + { + "address": "0x140016598", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x70]" + }, + { + "address": "0x14001659d", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x10]" + }, + { + "address": "0x1400165a1", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x18]" + }, + { + "address": "0x1400165a5", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x1400165a8", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400165a9", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400187b0", + "name": "", + "blocks": [ + { + "address": "0x1400187b0", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400187b0", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbx" + }, + { + "address": "0x1400187b5", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x1400187ba", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x1400187bb", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400187bf", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rdx" + }, + { + "address": "0x1400187c2", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x1400187c5", + "size": 6, + "mnemonic": "mov", + "operands": "eax, dword ptr [rip + 0x18dc5]" + }, + { + "address": "0x1400187cb", + "size": 6, + "mnemonic": "test", + "operands": "dword ptr [rcx + 0x3a8], eax" + }, + { + "address": "0x1400187d1", + "size": 2, + "mnemonic": "je", + "operands": "0x1400187e6" + } + ], + "successors": [ + "0x1400187e6", + "0x1400187d3" + ] + }, + { + "address": "0x1400187e6", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400187e6", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 5" + }, + { + "address": "0x1400187eb", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca20" + }, + { + "address": "0x1400187f0", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x1400187f1", + "size": 7, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rdi + 0x88]" + }, + { + "address": "0x1400187f8", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rbx" + }, + { + "address": "0x1400187fd", + "size": 3, + "mnemonic": "cmp", + "operands": "rbx, qword ptr [rsi]" + }, + { + "address": "0x140018800", + "size": 2, + "mnemonic": "je", + "operands": "0x140018840" + } + ], + "successors": [ + "0x140018840", + "0x140018802" + ] + }, + { + "address": "0x1400187d3", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400187d3", + "size": 8, + "mnemonic": "cmp", + "operands": "qword ptr [rcx + 0x90], 0" + }, + { + "address": "0x1400187db", + "size": 2, + "mnemonic": "je", + "operands": "0x1400187e6" + } + ], + "successors": [ + "0x1400187e6", + "0x1400187dd" + ] + }, + { + "address": "0x140018840", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140018840", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 5" + }, + { + "address": "0x140018845", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca74" + }, + { + "address": "0x14001884a", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x14001884d", + "size": 2, + "mnemonic": "je", + "operands": "0x140018862" + } + ], + "successors": [ + "0x140018862", + "0x14001884f" + ] + }, + { + "address": "0x140018802", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140018802", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x140018805", + "size": 2, + "mnemonic": "je", + "operands": "0x140018829" + } + ], + "successors": [ + "0x140018829", + "0x140018807" + ] + }, + { + "address": "0x1400187dd", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400187dd", + "size": 7, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rcx + 0x88]" + }, + { + "address": "0x1400187e4", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001884a" + } + ], + "successors": [ + "0x14001884a" + ] + }, + { + "address": "0x140018862", + "size": 21, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140018862", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140018867", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140018868", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x14001886c", + "size": 7, + "mnemonic": "cmp", + "operands": "byte ptr [rip + 0x1afd9], 0" + }, + { + "address": "0x140018873", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400188c1" + }, + { + "address": "0x140018875", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x19204]" + }, + { + "address": "0x14001887c", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x1afb5], rcx" + }, + { + "address": "0x140018883", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x18eb6]" + }, + { + "address": "0x14001888a", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x190df]" + }, + { + "address": "0x140018891", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x1afa8], rax" + }, + { + "address": "0x140018898", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rip + 0x1af91], rcx" + }, + { + "address": "0x14001889f", + "size": 5, + "mnemonic": "call", + "operands": "0x1400118e0" + }, + { + "address": "0x1400188a4", + "size": 7, + "mnemonic": "lea", + "operands": "r9, [rip + 0x1af95]" + }, + { + "address": "0x1400188ab", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rax" + }, + { + "address": "0x1400188ae", + "size": 2, + "mnemonic": "mov", + "operands": "dl, 1" + }, + { + "address": "0x1400188b0", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0xfffffffd" + }, + { + "address": "0x1400188b5", + "size": 5, + "mnemonic": "call", + "operands": "0x140018540" + }, + { + "address": "0x1400188ba", + "size": 7, + "mnemonic": "mov", + "operands": "byte ptr [rip + 0x1af8b], 1" + }, + { + "address": "0x1400188c1", + "size": 2, + "mnemonic": "mov", + "operands": "al, 1" + }, + { + "address": "0x1400188c3", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400188c7", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001884f", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001884f", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140018852", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x38]" + }, + { + "address": "0x140018857", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14001885c", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140018860", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140018861", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140018829", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140018829", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsi]" + }, + { + "address": "0x14001882c", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rdi + 0x88], rax" + }, + { + "address": "0x140018833", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rax" + }, + { + "address": "0x140018838", + "size": 3, + "mnemonic": "lock inc", + "operands": "dword ptr [rax]" + }, + { + "address": "0x14001883b", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140018840", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 5" + }, + { + "address": "0x140018845", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca74" + }, + { + "address": "0x14001884a", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x14001884d", + "size": 2, + "mnemonic": "je", + "operands": "0x140018862" + } + ], + "successors": [ + "0x140018862", + "0x14001884f" + ] + }, + { + "address": "0x140018807", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140018807", + "size": 3, + "mnemonic": "or", + "operands": "eax, 0xffffffff" + }, + { + "address": "0x14001880a", + "size": 4, + "mnemonic": "lock xadd", + "operands": "dword ptr [rbx], eax" + }, + { + "address": "0x14001880e", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x140018811", + "size": 2, + "mnemonic": "jne", + "operands": "0x140018829" + }, + { + "address": "0x140018813", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x18f26]" + }, + { + "address": "0x14001881a", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001881f", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, rax" + }, + { + "address": "0x140018822", + "size": 2, + "mnemonic": "je", + "operands": "0x140018829" + } + ], + "successors": [ + "0x140018829", + "0x140018824" + ] + }, + { + "address": "0x14001884a", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001884a", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x14001884d", + "size": 2, + "mnemonic": "je", + "operands": "0x140018862" + } + ], + "successors": [ + "0x140018862", + "0x14001884f" + ] + }, + { + "address": "0x140018824", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140018824", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140018829", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsi]" + }, + { + "address": "0x14001882c", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rdi + 0x88], rax" + }, + { + "address": "0x140018833", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rax" + }, + { + "address": "0x140018838", + "size": 3, + "mnemonic": "lock inc", + "operands": "dword ptr [rax]" + }, + { + "address": "0x14001883b", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140018840", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 5" + }, + { + "address": "0x140018845", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca74" + }, + { + "address": "0x14001884a", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x14001884d", + "size": 2, + "mnemonic": "je", + "operands": "0x140018862" + } + ], + "successors": [ + "0x140018862", + "0x14001884f" + ] + } + ] + }, + { + "address": "0x140018230", + "name": "", + "blocks": [ + { + "address": "0x140018230", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140018230", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140018232", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x140018236", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, ecx" + }, + { + "address": "0x140018238", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14001823a", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x20]" + }, + { + "address": "0x14001823f", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d89c" + }, + { + "address": "0x140018244", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rip + 0x1b5fd], 0" + }, + { + "address": "0x14001824b", + "size": 3, + "mnemonic": "cmp", + "operands": "ebx, -2" + }, + { + "address": "0x14001824e", + "size": 2, + "mnemonic": "jne", + "operands": "0x140018262" + }, + { + "address": "0x140018250", + "size": 10, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x1b5ee], 1" + }, + { + "address": "0x14001825a", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x8000]" + }, + { + "address": "0x140018260", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140018277" + } + ], + "successors": [ + "0x140018277" + ] + }, + { + "address": "0x140018277", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140018277", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, eax" + }, + { + "address": "0x140018279", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140018292" + } + ], + "successors": [ + "0x140018292" + ] + }, + { + "address": "0x140018292", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140018292", + "size": 5, + "mnemonic": "cmp", + "operands": "byte ptr [rsp + 0x38], 0" + }, + { + "address": "0x140018297", + "size": 2, + "mnemonic": "je", + "operands": "0x1400182a5" + } + ], + "successors": [ + "0x1400182a5", + "0x140018299" + ] + }, + { + "address": "0x1400182a5", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400182a5", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ebx" + }, + { + "address": "0x1400182a7", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x40" + }, + { + "address": "0x1400182ab", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x1400182ac", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140018299", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140018299", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x20]" + }, + { + "address": "0x14001829e", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rcx + 0x3a8], 0xfffffffd" + }, + { + "address": "0x1400182a5", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ebx" + }, + { + "address": "0x1400182a7", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x40" + }, + { + "address": "0x1400182ab", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x1400182ac", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000ef78", + "name": "", + "blocks": [ + { + "address": "0x14000ef78", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ef78", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000ef7d", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rsi" + }, + { + "address": "0x14000ef82", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000ef83", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000ef87", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x14000ef8a", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14000ef8d", + "size": 2, + "mnemonic": "je", + "operands": "0x14000efd2" + } + ], + "successors": [ + "0x14000efd2", + "0x14000ef8f" + ] + }, + { + "address": "0x14000efd2", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000efd2", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000efd4", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14000efd9", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14000efde", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000efe2", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000efe3", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000ef8f", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ef8f", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0x55" + }, + { + "address": "0x14000ef94", + "size": 5, + "mnemonic": "call", + "operands": "0x14000dca0" + }, + { + "address": "0x14000ef99", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rax" + }, + { + "address": "0x14000ef9c", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, 0x55" + }, + { + "address": "0x14000efa0", + "size": 2, + "mnemonic": "jae", + "operands": "0x14000efd2" + }, + { + "address": "0x14000efa2", + "size": 8, + "mnemonic": "lea", + "operands": "rcx, [rax*2 + 2]" + }, + { + "address": "0x14000efaa", + "size": 5, + "mnemonic": "call", + "operands": "0x140015200" + }, + { + "address": "0x14000efaf", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x14000efb2", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000efb5", + "size": 2, + "mnemonic": "je", + "operands": "0x14000efd2" + } + ], + "successors": [ + "0x14000efd2", + "0x14000efb7" + ] + }, + { + "address": "0x14000efb7", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000efb7", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rsi + 1]" + }, + { + "address": "0x14000efbb", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rdi" + }, + { + "address": "0x14000efbe", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rdx" + }, + { + "address": "0x14000efc1", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x14000efc4", + "size": 5, + "mnemonic": "call", + "operands": "0x140017510" + }, + { + "address": "0x14000efc9", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000efcb", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000efe4" + }, + { + "address": "0x14000efcd", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x14000efd0", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000efd4" + } + ], + "successors": [ + "0x14000efd4" + ] + }, + { + "address": "0x14000efd4", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000efd4", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14000efd9", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14000efde", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000efe2", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000efe3", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140015e88", + "name": "", + "blocks": [ + { + "address": "0x140015e88", + "size": 27, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015e88", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140015e8a", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140015e8b", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140015e8c", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140015e8d", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140015e8f", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140015e91", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140015e93", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0xd0" + }, + { + "address": "0x140015e9a", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x1b19f]" + }, + { + "address": "0x140015ea1", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x140015ea4", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0xc0], rax" + }, + { + "address": "0x140015eac", + "size": 8, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x130]" + }, + { + "address": "0x140015eb4", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x140015eb6", + "size": 3, + "mnemonic": "mov", + "operands": "ebp, r9d" + }, + { + "address": "0x140015eb9", + "size": 3, + "mnemonic": "mov", + "operands": "r14, r8" + }, + { + "address": "0x140015ebc", + "size": 3, + "mnemonic": "mov", + "operands": "r12, rcx" + }, + { + "address": "0x140015ebf", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rsi], rdi" + }, + { + "address": "0x140015ec2", + "size": 3, + "mnemonic": "cmp", + "operands": "edx, 1" + }, + { + "address": "0x140015ec5", + "size": 6, + "mnemonic": "jne", + "operands": "0x140015fa5" + }, + { + "address": "0x140015ecb", + "size": 5, + "mnemonic": "lea", + "operands": "r9, [rsp + 0x40]" + }, + { + "address": "0x140015ed0", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x20], 0x80" + }, + { + "address": "0x140015ed8", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, ebp" + }, + { + "address": "0x140015edb", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r14" + }, + { + "address": "0x140015ede", + "size": 5, + "mnemonic": "call", + "operands": "0x140015d0c" + }, + { + "address": "0x140015ee3", + "size": 3, + "mnemonic": "movsxd", + "operands": "rbx, eax" + }, + { + "address": "0x140015ee6", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140015ee8", + "size": 2, + "mnemonic": "je", + "operands": "0x140015f2d" + } + ], + "successors": [ + "0x140015f2d", + "0x140015eea" + ] + } + ] + }, + { + "address": "0x14001bb54", + "name": "", + "blocks": [ + { + "address": "0x14001bb54", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bb54", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14001bb59", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x14001bb5e", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x14001bb63", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001bb64", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14001bb66", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14001bb68", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001bb6c", + "size": 2, + "mnemonic": "xor", + "operands": "esi, esi" + }, + { + "address": "0x14001bb6e", + "size": 3, + "mnemonic": "mov", + "operands": "r14, r8" + }, + { + "address": "0x14001bb71", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, edx" + }, + { + "address": "0x14001bb73", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rcx" + }, + { + "address": "0x14001bb76", + "size": 2, + "mnemonic": "test", + "operands": "edx, edx" + }, + { + "address": "0x14001bb78", + "size": 2, + "mnemonic": "js", + "operands": "0x14001bbb0" + } + ], + "successors": [ + "0x14001bbb0", + "0x14001bb7a" + ] + }, + { + "address": "0x14001bbb0", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001bbb0", + "size": 2, + "mnemonic": "xor", + "operands": "al, al" + }, + { + "address": "0x14001bbb2", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14001bbb7", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14001bbbc", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14001bbc1", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001bbc5", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14001bbc7", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001bbc9", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001bbca", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001bb7a", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bb7a", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r14]" + }, + { + "address": "0x14001bb7d", + "size": 3, + "mnemonic": "lea", + "operands": "eax, [rsi + rbx]" + }, + { + "address": "0x14001bb80", + "size": 1, + "mnemonic": "cdq", + "operands": "" + }, + { + "address": "0x14001bb81", + "size": 2, + "mnemonic": "sub", + "operands": "eax, edx" + }, + { + "address": "0x14001bb83", + "size": 2, + "mnemonic": "sar", + "operands": "eax, 1" + }, + { + "address": "0x14001bb85", + "size": 3, + "mnemonic": "movsxd", + "operands": "r15, eax" + }, + { + "address": "0x14001bb88", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r15" + }, + { + "address": "0x14001bb8b", + "size": 4, + "mnemonic": "shl", + "operands": "rdi, 4" + }, + { + "address": "0x14001bb8f", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rdi + rbp]" + }, + { + "address": "0x14001bb93", + "size": 5, + "mnemonic": "call", + "operands": "0x140017230" + }, + { + "address": "0x14001bb98", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001bb9a", + "size": 2, + "mnemonic": "je", + "operands": "0x14001bbcb" + } + ], + "successors": [ + "0x14001bbcb", + "0x14001bb9c" + ] + }, + { + "address": "0x14001bbcb", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bbcb", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 8]" + }, + { + "address": "0x14001bbcf", + "size": 3, + "mnemonic": "add", + "operands": "rax, rdi" + }, + { + "address": "0x14001bbd2", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [r14], rax" + }, + { + "address": "0x14001bbd5", + "size": 2, + "mnemonic": "mov", + "operands": "al, 1" + }, + { + "address": "0x14001bbd7", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001bbb2" + } + ], + "successors": [ + "0x14001bbb2" + ] + }, + { + "address": "0x14001bb9c", + "size": 16, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001bb9c", + "size": 4, + "mnemonic": "lea", + "operands": "ecx, [r15 - 1]" + }, + { + "address": "0x14001bba0", + "size": 3, + "mnemonic": "cmovns", + "operands": "ecx, ebx" + }, + { + "address": "0x14001bba3", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, ecx" + }, + { + "address": "0x14001bba5", + "size": 4, + "mnemonic": "lea", + "operands": "ecx, [r15 + 1]" + }, + { + "address": "0x14001bba9", + "size": 3, + "mnemonic": "cmovns", + "operands": "esi, ecx" + }, + { + "address": "0x14001bbac", + "size": 2, + "mnemonic": "cmp", + "operands": "esi, ebx" + }, + { + "address": "0x14001bbae", + "size": 2, + "mnemonic": "jle", + "operands": "0x14001bb7a" + }, + { + "address": "0x14001bbb0", + "size": 2, + "mnemonic": "xor", + "operands": "al, al" + }, + { + "address": "0x14001bbb2", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14001bbb7", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14001bbbc", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14001bbc1", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001bbc5", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14001bbc7", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001bbc9", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001bbca", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001bbb2", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001bbb2", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14001bbb7", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14001bbbc", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14001bbc1", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001bbc5", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14001bbc7", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001bbc9", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001bbca", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001b9e4", + "name": "", + "blocks": [ + { + "address": "0x14001b9e4", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001b9e4", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbx" + }, + { + "address": "0x14001b9e9", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x14001b9ee", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001b9ef", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001b9f3", + "size": 2, + "mnemonic": "xor", + "operands": "esi, esi" + }, + { + "address": "0x14001b9f5", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x14001b9f8", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x30], esi" + }, + { + "address": "0x14001b9fc", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14001b9ff", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001ba02", + "size": 2, + "mnemonic": "je", + "operands": "0x14001ba57" + } + ], + "successors": [ + "0x14001ba57", + "0x14001ba04" + ] + }, + { + "address": "0x14001ba57", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ba57", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rdi + 8]" + }, + { + "address": "0x14001ba5a", + "size": 5, + "mnemonic": "lea", + "operands": "r8, [rsp + 0x30]" + }, + { + "address": "0x14001ba5f", + "size": 6, + "mnemonic": "mov", + "operands": "r9d, 2" + }, + { + "address": "0x14001ba65", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0x20001004" + }, + { + "address": "0x14001ba6a", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x4758]" + }, + { + "address": "0x14001ba70", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001ba72", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001ba78" + }, + { + "address": "0x14001ba74", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001ba76", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001ba86" + } + ], + "successors": [ + "0x14001ba86" + ] + }, + { + "address": "0x14001ba04", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ba04", + "size": 3, + "mnemonic": "cmp", + "operands": "word ptr [rcx], si" + }, + { + "address": "0x14001ba07", + "size": 2, + "mnemonic": "je", + "operands": "0x14001ba57" + } + ], + "successors": [ + "0x14001ba57", + "0x14001ba09" + ] + }, + { + "address": "0x14001ba86", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001ba86", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14001ba8b", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14001ba90", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001ba94", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001ba95", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001ba09", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ba09", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0xc058]" + }, + { + "address": "0x14001ba10", + "size": 5, + "mnemonic": "call", + "operands": "0x14001d690" + }, + { + "address": "0x14001ba15", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001ba17", + "size": 2, + "mnemonic": "je", + "operands": "0x14001ba57" + } + ], + "successors": [ + "0x14001ba57", + "0x14001ba19" + ] + }, + { + "address": "0x14001ba19", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ba19", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0xc060]" + }, + { + "address": "0x14001ba20", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x14001ba23", + "size": 5, + "mnemonic": "call", + "operands": "0x14001d690" + }, + { + "address": "0x14001ba28", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001ba2a", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001ba4d" + }, + { + "address": "0x14001ba2c", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rdi + 8]" + }, + { + "address": "0x14001ba2f", + "size": 4, + "mnemonic": "lea", + "operands": "r9d, [rsi + 2]" + }, + { + "address": "0x14001ba33", + "size": 5, + "mnemonic": "lea", + "operands": "r8, [rsp + 0x30]" + }, + { + "address": "0x14001ba38", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0x2000000b" + }, + { + "address": "0x14001ba3d", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x4785]" + }, + { + "address": "0x14001ba43", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001ba45", + "size": 2, + "mnemonic": "je", + "operands": "0x14001ba74" + } + ], + "successors": [ + "0x14001ba74", + "0x14001ba47" + ] + }, + { + "address": "0x14001ba74", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ba74", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001ba76", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001ba86" + } + ], + "successors": [ + "0x14001ba86" + ] + }, + { + "address": "0x14001ba47", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001ba47", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [rsp + 0x30]" + }, + { + "address": "0x14001ba4b", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001ba86" + } + ], + "successors": [ + "0x14001ba86" + ] + } + ] + }, + { + "address": "0x14001b5b0", + "name": "", + "blocks": [ + { + "address": "0x14001b5b0", + "size": 18, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001b5b0", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14001b5b5", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001b5b6", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001b5ba", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14001b5bd", + "size": 5, + "mnemonic": "call", + "operands": "0x1400118c4" + }, + { + "address": "0x14001b5c2", + "size": 4, + "mnemonic": "or", + "operands": "r8, 0xffffffffffffffff" + }, + { + "address": "0x14001b5c6", + "size": 3, + "mnemonic": "mov", + "operands": "r10, rax" + }, + { + "address": "0x14001b5c9", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x14001b5cb", + "size": 7, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rax + 0x98]" + }, + { + "address": "0x14001b5d2", + "size": 3, + "mnemonic": "inc", + "operands": "r8" + }, + { + "address": "0x14001b5d5", + "size": 5, + "mnemonic": "cmp", + "operands": "word ptr [rdx + r8*2], di" + }, + { + "address": "0x14001b5da", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001b5d2" + }, + { + "address": "0x14001b5dc", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x14001b5de", + "size": 4, + "mnemonic": "cmp", + "operands": "r8, 3" + }, + { + "address": "0x14001b5e2", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 2" + }, + { + "address": "0x14001b5e7", + "size": 3, + "mnemonic": "sete", + "operands": "al" + }, + { + "address": "0x14001b5ea", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [r10 + 0xb0], eax" + }, + { + "address": "0x14001b5f1", + "size": 2, + "mnemonic": "je", + "operands": "0x14001b61b" + } + ], + "successors": [ + "0x14001b61b", + "0x14001b5f3" + ] + }, + { + "address": "0x14001b61b", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001b61b", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [r10 + 0xac], ecx" + }, + { + "address": "0x14001b622", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 1" + }, + { + "address": "0x14001b627", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x25e]" + }, + { + "address": "0x14001b62e", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x4bac]" + }, + { + "address": "0x14001b634", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [rbx], 4" + }, + { + "address": "0x14001b637", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001b63b" + }, + { + "address": "0x14001b639", + "size": 2, + "mnemonic": "mov", + "operands": "dword ptr [rbx], edi" + }, + { + "address": "0x14001b63b", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001b640", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001b644", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001b645", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001b5f3", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001b5f3", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, edi" + }, + { + "address": "0x14001b5f6", + "size": 4, + "mnemonic": "movzx", + "operands": "r8d, word ptr [rdx]" + }, + { + "address": "0x14001b5fa", + "size": 3, + "mnemonic": "add", + "operands": "rdx, rcx" + }, + { + "address": "0x14001b5fd", + "size": 4, + "mnemonic": "lea", + "operands": "eax, [r8 - 0x41]" + }, + { + "address": "0x14001b601", + "size": 4, + "mnemonic": "cmp", + "operands": "ax, 0x19" + }, + { + "address": "0x14001b605", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14001b613" + }, + { + "address": "0x14001b607", + "size": 5, + "mnemonic": "sub", + "operands": "r8w, 0x61" + }, + { + "address": "0x14001b60c", + "size": 5, + "mnemonic": "cmp", + "operands": "r8w, 0x19" + }, + { + "address": "0x14001b611", + "size": 2, + "mnemonic": "ja", + "operands": "0x14001b618" + } + ], + "successors": [ + "0x14001b618", + "0x14001b613" + ] + }, + { + "address": "0x14001b618", + "size": 12, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001b618", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, r9d" + }, + { + "address": "0x14001b61b", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [r10 + 0xac], ecx" + }, + { + "address": "0x14001b622", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 1" + }, + { + "address": "0x14001b627", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x25e]" + }, + { + "address": "0x14001b62e", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x4bac]" + }, + { + "address": "0x14001b634", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [rbx], 4" + }, + { + "address": "0x14001b637", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001b63b" + }, + { + "address": "0x14001b639", + "size": 2, + "mnemonic": "mov", + "operands": "dword ptr [rbx], edi" + }, + { + "address": "0x14001b63b", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001b640", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001b644", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001b645", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001b613", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001b613", + "size": 3, + "mnemonic": "inc", + "operands": "r9d" + }, + { + "address": "0x14001b616", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001b5f6" + } + ], + "successors": [ + "0x14001b5f6" + ] + }, + { + "address": "0x14001b5f6", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001b5f6", + "size": 4, + "mnemonic": "movzx", + "operands": "r8d, word ptr [rdx]" + }, + { + "address": "0x14001b5fa", + "size": 3, + "mnemonic": "add", + "operands": "rdx, rcx" + }, + { + "address": "0x14001b5fd", + "size": 4, + "mnemonic": "lea", + "operands": "eax, [r8 - 0x41]" + }, + { + "address": "0x14001b601", + "size": 4, + "mnemonic": "cmp", + "operands": "ax, 0x19" + }, + { + "address": "0x14001b605", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14001b613" + }, + { + "address": "0x14001b607", + "size": 5, + "mnemonic": "sub", + "operands": "r8w, 0x61" + }, + { + "address": "0x14001b60c", + "size": 5, + "mnemonic": "cmp", + "operands": "r8w, 0x19" + }, + { + "address": "0x14001b611", + "size": 2, + "mnemonic": "ja", + "operands": "0x14001b618" + } + ], + "successors": [ + "0x14001b618", + "0x14001b613" + ] + } + ] + }, + { + "address": "0x14001b4e0", + "name": "", + "blocks": [ + { + "address": "0x14001b4e0", + "size": 39, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001b4e0", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14001b4e5", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001b4e6", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001b4ea", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14001b4ed", + "size": 5, + "mnemonic": "call", + "operands": "0x1400118c4" + }, + { + "address": "0x14001b4f2", + "size": 4, + "mnemonic": "or", + "operands": "r8, 0xffffffffffffffff" + }, + { + "address": "0x14001b4f6", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r8" + }, + { + "address": "0x14001b4f9", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x14001b4fb", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rax + 0x98]" + }, + { + "address": "0x14001b502", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdx]" + }, + { + "address": "0x14001b505", + "size": 3, + "mnemonic": "inc", + "operands": "r9" + }, + { + "address": "0x14001b508", + "size": 5, + "mnemonic": "cmp", + "operands": "word ptr [rax + r9*2], di" + }, + { + "address": "0x14001b50d", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001b505" + }, + { + "address": "0x14001b50f", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x14001b511", + "size": 4, + "mnemonic": "cmp", + "operands": "r9, 3" + }, + { + "address": "0x14001b515", + "size": 3, + "mnemonic": "sete", + "operands": "al" + }, + { + "address": "0x14001b518", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rdx + 0x18], eax" + }, + { + "address": "0x14001b51b", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdx + 8]" + }, + { + "address": "0x14001b51f", + "size": 3, + "mnemonic": "inc", + "operands": "r8" + }, + { + "address": "0x14001b522", + "size": 5, + "mnemonic": "cmp", + "operands": "word ptr [rax + r8*2], di" + }, + { + "address": "0x14001b527", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001b51f" + }, + { + "address": "0x14001b529", + "size": 4, + "mnemonic": "cmp", + "operands": "r8, 3" + }, + { + "address": "0x14001b52d", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x14001b52f", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 2" + }, + { + "address": "0x14001b535", + "size": 3, + "mnemonic": "sete", + "operands": "al" + }, + { + "address": "0x14001b538", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rdx + 0x1c], eax" + }, + { + "address": "0x14001b53b", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 4], edi" + }, + { + "address": "0x14001b53e", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rdx + 0x18], edi" + }, + { + "address": "0x14001b541", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001b56e" + }, + { + "address": "0x14001b543", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdx]" + }, + { + "address": "0x14001b546", + "size": 3, + "mnemonic": "mov", + "operands": "r10d, edi" + }, + { + "address": "0x14001b549", + "size": 4, + "mnemonic": "movzx", + "operands": "r9d, word ptr [rcx]" + }, + { + "address": "0x14001b54d", + "size": 3, + "mnemonic": "add", + "operands": "rcx, r8" + }, + { + "address": "0x14001b550", + "size": 4, + "mnemonic": "lea", + "operands": "eax, [r9 - 0x41]" + }, + { + "address": "0x14001b554", + "size": 4, + "mnemonic": "cmp", + "operands": "ax, 0x19" + }, + { + "address": "0x14001b558", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14001b566" + }, + { + "address": "0x14001b55a", + "size": 5, + "mnemonic": "sub", + "operands": "r9w, 0x61" + }, + { + "address": "0x14001b55f", + "size": 5, + "mnemonic": "cmp", + "operands": "r9w, 0x19" + }, + { + "address": "0x14001b564", + "size": 2, + "mnemonic": "ja", + "operands": "0x14001b56b" + } + ], + "successors": [ + "0x14001b56b", + "0x14001b566" + ] + }, + { + "address": "0x14001b56b", + "size": 20, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001b56b", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, r10d" + }, + { + "address": "0x14001b56e", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rdx + 0x14], r8d" + }, + { + "address": "0x14001b572", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0xcf]" + }, + { + "address": "0x14001b579", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 1" + }, + { + "address": "0x14001b57e", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x4c5c]" + }, + { + "address": "0x14001b584", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbx]" + }, + { + "address": "0x14001b586", + "size": 3, + "mnemonic": "test", + "operands": "cl, 7" + }, + { + "address": "0x14001b589", + "size": 3, + "mnemonic": "setne", + "operands": "dl" + }, + { + "address": "0x14001b58c", + "size": 4, + "mnemonic": "bt", + "operands": "ecx, 9" + }, + { + "address": "0x14001b590", + "size": 3, + "mnemonic": "setb", + "operands": "al" + }, + { + "address": "0x14001b593", + "size": 2, + "mnemonic": "and", + "operands": "dl, al" + }, + { + "address": "0x14001b595", + "size": 4, + "mnemonic": "bt", + "operands": "ecx, 8" + }, + { + "address": "0x14001b599", + "size": 3, + "mnemonic": "setb", + "operands": "al" + }, + { + "address": "0x14001b59c", + "size": 2, + "mnemonic": "test", + "operands": "al, dl" + }, + { + "address": "0x14001b59e", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001b5a2" + }, + { + "address": "0x14001b5a0", + "size": 2, + "mnemonic": "mov", + "operands": "dword ptr [rbx], edi" + }, + { + "address": "0x14001b5a2", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001b5a7", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001b5ab", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001b5ac", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001b566", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001b566", + "size": 3, + "mnemonic": "inc", + "operands": "r10d" + }, + { + "address": "0x14001b569", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001b549" + } + ], + "successors": [ + "0x14001b549" + ] + }, + { + "address": "0x14001b549", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001b549", + "size": 4, + "mnemonic": "movzx", + "operands": "r9d, word ptr [rcx]" + }, + { + "address": "0x14001b54d", + "size": 3, + "mnemonic": "add", + "operands": "rcx, r8" + }, + { + "address": "0x14001b550", + "size": 4, + "mnemonic": "lea", + "operands": "eax, [r9 - 0x41]" + }, + { + "address": "0x14001b554", + "size": 4, + "mnemonic": "cmp", + "operands": "ax, 0x19" + }, + { + "address": "0x14001b558", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14001b566" + }, + { + "address": "0x14001b55a", + "size": 5, + "mnemonic": "sub", + "operands": "r9w, 0x61" + }, + { + "address": "0x14001b55f", + "size": 5, + "mnemonic": "cmp", + "operands": "r9w, 0x19" + }, + { + "address": "0x14001b564", + "size": 2, + "mnemonic": "ja", + "operands": "0x14001b56b" + } + ], + "successors": [ + "0x14001b56b", + "0x14001b566" + ] + } + ] + }, + { + "address": "0x140012164", + "name": "", + "blocks": [ + { + "address": "0x140012164", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140012164", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140012169", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x14001216e", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x140012173", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140012174", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x140012178", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x23f19]" + }, + { + "address": "0x14001217f", + "size": 3, + "mnemonic": "mov", + "operands": "ebp, r9d" + }, + { + "address": "0x140012182", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, r8d" + }, + { + "address": "0x140012185", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x140012188", + "size": 2, + "mnemonic": "mov", + "operands": "esi, ecx" + }, + { + "address": "0x14001218a", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, -1" + }, + { + "address": "0x14001218e", + "size": 2, + "mnemonic": "je", + "operands": "0x1400121c9" + } + ], + "successors": [ + "0x1400121c9", + "0x140012190" + ] + }, + { + "address": "0x1400121c9", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400121c9", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, ebx" + }, + { + "address": "0x1400121cc", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rdi" + }, + { + "address": "0x1400121cf", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, esi" + }, + { + "address": "0x1400121d1", + "size": 5, + "mnemonic": "call", + "operands": "0x14001c034" + }, + { + "address": "0x1400121d6", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x1400121db", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x1400121e0", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x1400121e5", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x1400121e9", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400121ea", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140012190", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140012190", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140012193", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400121b7" + }, + { + "address": "0x140012195", + "size": 7, + "mnemonic": "lea", + "operands": "r9, [rip + 0x14804]" + }, + { + "address": "0x14001219c", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip + 0x147f5]" + }, + { + "address": "0x1400121a3", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x147f6]" + }, + { + "address": "0x1400121aa", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rax + 0x13]" + }, + { + "address": "0x1400121ad", + "size": 5, + "mnemonic": "call", + "operands": "0x140011c00" + }, + { + "address": "0x1400121b2", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x1400121b5", + "size": 2, + "mnemonic": "je", + "operands": "0x1400121c9" + } + ], + "successors": [ + "0x1400121c9", + "0x1400121b7" + ] + }, + { + "address": "0x1400121b7", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400121b7", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, ebp" + }, + { + "address": "0x1400121ba", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, ebx" + }, + { + "address": "0x1400121bd", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rdi" + }, + { + "address": "0x1400121c0", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, esi" + }, + { + "address": "0x1400121c2", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3a0" + }, + { + "address": "0x1400121c7", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400121d6" + } + ], + "successors": [ + "0x1400121d6" + ] + }, + { + "address": "0x1400121d6", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400121d6", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x1400121db", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x1400121e0", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x1400121e5", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x1400121e9", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400121ea", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001d3e4", + "name": "", + "blocks": [ + { + "address": "0x14001d3e4", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001d3e4", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x38" + }, + { + "address": "0x14001d3e8", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001d3ea", + "size": 4, + "mnemonic": "cmp", + "operands": "r9d, 0xa" + }, + { + "address": "0x14001d3ee", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001d3f6" + }, + { + "address": "0x14001d3f0", + "size": 2, + "mnemonic": "test", + "operands": "ecx, ecx" + }, + { + "address": "0x14001d3f2", + "size": 2, + "mnemonic": "jns", + "operands": "0x14001d3f6" + }, + { + "address": "0x14001d3f4", + "size": 2, + "mnemonic": "mov", + "operands": "al, 1" + }, + { + "address": "0x14001d3f6", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x20], al" + }, + { + "address": "0x14001d3fa", + "size": 5, + "mnemonic": "call", + "operands": "0x14001d378" + }, + { + "address": "0x14001d3ff", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x38" + }, + { + "address": "0x14001d403", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140016d88", + "name": "", + "blocks": [ + { + "address": "0x140016d88", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016d88", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140016d8a", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140016d8e", + "size": 3, + "mnemonic": "test", + "operands": "r8, r8" + }, + { + "address": "0x140016d91", + "size": 7, + "mnemonic": "lea", + "operands": "rbx, [rip + 0x1c9b0]" + }, + { + "address": "0x140016d98", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x2400" + }, + { + "address": "0x140016d9d", + "size": 3, + "mnemonic": "mov", + "operands": "r10, rcx" + }, + { + "address": "0x140016da0", + "size": 4, + "mnemonic": "cmovne", + "operands": "rbx, r8" + }, + { + "address": "0x140016da4", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0x3ff" + }, + { + "address": "0x140016da9", + "size": 2, + "mnemonic": "add", + "operands": "eax, edx" + }, + { + "address": "0x140016dab", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rbx], 0" + }, + { + "address": "0x140016dae", + "size": 2, + "mnemonic": "jne", + "operands": "0x140016df7" + }, + { + "address": "0x140016db0", + "size": 3, + "mnemonic": "cmp", + "operands": "ax, cx" + }, + { + "address": "0x140016db3", + "size": 2, + "mnemonic": "ja", + "operands": "0x140016dc2" + } + ], + "successors": [ + "0x140016dc2", + "0x140016db5" + ] + }, + { + "address": "0x140016dc2", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016dc2", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x2800" + }, + { + "address": "0x140016dc7", + "size": 2, + "mnemonic": "add", + "operands": "eax, edx" + }, + { + "address": "0x140016dc9", + "size": 3, + "mnemonic": "cmp", + "operands": "ax, cx" + }, + { + "address": "0x140016dcc", + "size": 2, + "mnemonic": "ja", + "operands": "0x140016de4" + } + ], + "successors": [ + "0x140016de4", + "0x140016dce" + ] + }, + { + "address": "0x140016db5", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016db5", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r9" + }, + { + "address": "0x140016db8", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140016dbb", + "size": 5, + "mnemonic": "call", + "operands": "0x14001c5a0" + }, + { + "address": "0x140016dc0", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140016e25" + } + ], + "successors": [ + "0x140016e25" + ] + }, + { + "address": "0x140016de4", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016de4", + "size": 3, + "mnemonic": "movzx", + "operands": "edx, dx" + }, + { + "address": "0x140016de7", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rbx" + }, + { + "address": "0x140016dea", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r10" + }, + { + "address": "0x140016ded", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140016df1", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140016df2", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14001c4f4" + } + ], + "successors": [ + "0x14001c4f4" + ] + }, + { + "address": "0x140016dce", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016dce", + "size": 3, + "mnemonic": "movzx", + "operands": "eax, dx" + }, + { + "address": "0x140016dd1", + "size": 3, + "mnemonic": "shl", + "operands": "eax, 0xa" + }, + { + "address": "0x140016dd4", + "size": 5, + "mnemonic": "and", + "operands": "eax, 0xfc9ffc00" + }, + { + "address": "0x140016dd9", + "size": 5, + "mnemonic": "add", + "operands": "eax, 0x10000" + }, + { + "address": "0x140016dde", + "size": 2, + "mnemonic": "mov", + "operands": "dword ptr [rbx], eax" + }, + { + "address": "0x140016de0", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140016de2", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140016e25" + } + ], + "successors": [ + "0x140016e25" + ] + }, + { + "address": "0x140016e25", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140016e25", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140016e29", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140016e2a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001c4f4", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001c4f4", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001c4f6", + "size": 3, + "mnemonic": "mov", + "operands": "r10, rcx" + }, + { + "address": "0x14001c4f9", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001c4fc", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001c507" + }, + { + "address": "0x14001c4fe", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [r8], rax" + }, + { + "address": "0x14001c501", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 1" + }, + { + "address": "0x14001c506", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001d930", + "name": "", + "blocks": [ + { + "address": "0x14001d930", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001d930", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x14001d932", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x158b7], 0" + }, + { + "address": "0x14001d939", + "size": 3, + "mnemonic": "mov", + "operands": "r10, r8" + }, + { + "address": "0x14001d93c", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdx" + }, + { + "address": "0x14001d93f", + "size": 3, + "mnemonic": "mov", + "operands": "r11, rcx" + }, + { + "address": "0x14001d942", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001d9a9" + }, + { + "address": "0x14001d944", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001d947", + "size": 2, + "mnemonic": "je", + "operands": "0x14001d9a3" + } + ], + "successors": [ + "0x14001d9a3", + "0x14001d949" + ] + }, + { + "address": "0x14001d9a3", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001d9a3", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001d9a4", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14001d8f0" + } + ], + "successors": [ + "0x14001d8f0" + ] + }, + { + "address": "0x14001d949", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001d949", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14001d94c", + "size": 2, + "mnemonic": "je", + "operands": "0x14001d9a3" + } + ], + "successors": [ + "0x14001d9a3", + "0x14001d94e" + ] + }, + { + "address": "0x14001d8f0", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001d8f0", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x14001d8f4", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001d8f7", + "size": 2, + "mnemonic": "je", + "operands": "0x14001d907" + } + ], + "successors": [ + "0x14001d907", + "0x14001d8f9" + ] + }, + { + "address": "0x14001d94e", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001d94e", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x7fffffff" + }, + { + "address": "0x14001d955", + "size": 2, + "mnemonic": "ja", + "operands": "0x14001d9a3" + } + ], + "successors": [ + "0x14001d9a3", + "0x14001d957" + ] + }, + { + "address": "0x14001d907", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001d907", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x14001d90c", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0x16" + }, + { + "address": "0x14001d912", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afb4" + }, + { + "address": "0x14001d917", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x7fffffff" + }, + { + "address": "0x14001d91c", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14001d920", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001d8f9", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001d8f9", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14001d8fc", + "size": 2, + "mnemonic": "je", + "operands": "0x14001d907" + } + ], + "successors": [ + "0x14001d907", + "0x14001d8fe" + ] + }, + { + "address": "0x14001d957", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001d957", + "size": 3, + "mnemonic": "test", + "operands": "r8, r8" + }, + { + "address": "0x14001d95a", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001d960" + }, + { + "address": "0x14001d95c", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001d95e", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001d95f", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001d8fe", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001d8fe", + "size": 7, + "mnemonic": "cmp", + "operands": "r8, 0x7fffffff" + }, + { + "address": "0x14001d905", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14001d917" + }, + { + "address": "0x14001d907", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x14001d90c", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0x16" + }, + { + "address": "0x14001d912", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afb4" + }, + { + "address": "0x14001d917", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x7fffffff" + }, + { + "address": "0x14001d91c", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14001d920", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140002b78", + "name": "", + "blocks": [ + { + "address": "0x140002b78", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140002b78", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x140002b7c", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1e96d]" + }, + { + "address": "0x140002b83", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rcx], rax" + }, + { + "address": "0x140002b86", + "size": 5, + "mnemonic": "call", + "operands": "0x140004cbc" + }, + { + "address": "0x140002b8b", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140002b8c", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x140002b90", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000dfac", + "name": "", + "blocks": [ + { + "address": "0x14000dfac", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000dfac", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000dfb1", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x14000dfb6", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x14000dfbb", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000dfbc", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000dfc0", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rdx" + }, + { + "address": "0x14000dfc3", + "size": 2, + "mnemonic": "mov", + "operands": "edi, ecx" + }, + { + "address": "0x14000dfc5", + "size": 5, + "mnemonic": "call", + "operands": "0x140011924" + }, + { + "address": "0x14000dfca", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x14000dfcd", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x14000dfd0", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000dfd3", + "size": 2, + "mnemonic": "je", + "operands": "0x14000dff4" + } + ], + "successors": [ + "0x14000dff4", + "0x14000dfd5" + ] + }, + { + "address": "0x14000dff4", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000dff4", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000dff6", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000dffb", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14000e000", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14000e005", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000e009", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000e00a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000dfd5", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000dfd5", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax]" + }, + { + "address": "0x14000dfd8", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rcx" + }, + { + "address": "0x14000dfdb", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rcx + 0xc0]" + }, + { + "address": "0x14000dfe2", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, r8" + }, + { + "address": "0x14000dfe5", + "size": 2, + "mnemonic": "je", + "operands": "0x14000dff4" + } + ], + "successors": [ + "0x14000dff4", + "0x14000dfe7" + ] + }, + { + "address": "0x14000dfe7", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000dfe7", + "size": 2, + "mnemonic": "cmp", + "operands": "dword ptr [rax], edi" + }, + { + "address": "0x14000dfe9", + "size": 2, + "mnemonic": "je", + "operands": "0x14000e00b" + } + ], + "successors": [ + "0x14000e00b", + "0x14000dfeb" + ] + }, + { + "address": "0x14000e00b", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000e00b", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000e00e", + "size": 2, + "mnemonic": "je", + "operands": "0x14000dff4" + } + ], + "successors": [ + "0x14000dff4", + "0x14000e010" + ] + }, + { + "address": "0x14000dfeb", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000dfeb", + "size": 4, + "mnemonic": "add", + "operands": "rax, 0x10" + }, + { + "address": "0x14000dfef", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, r8" + }, + { + "address": "0x14000dff2", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000dfe7" + }, + { + "address": "0x14000dff4", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000dff6", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000dffb", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14000e000", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14000e005", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000e009", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000e00a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000e010", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000e010", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [rax + 8]" + }, + { + "address": "0x14000e014", + "size": 3, + "mnemonic": "test", + "operands": "r8, r8" + }, + { + "address": "0x14000e017", + "size": 2, + "mnemonic": "je", + "operands": "0x14000dff4" + } + ], + "successors": [ + "0x14000dff4", + "0x14000e019" + ] + }, + { + "address": "0x14000e019", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000e019", + "size": 4, + "mnemonic": "cmp", + "operands": "r8, 5" + }, + { + "address": "0x14000e01d", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000e029" + }, + { + "address": "0x14000e01f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 8], r9" + }, + { + "address": "0x14000e023", + "size": 4, + "mnemonic": "lea", + "operands": "eax, [r8 - 4]" + }, + { + "address": "0x14000e027", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000dff6" + } + ], + "successors": [ + "0x14000dff6" + ] + }, + { + "address": "0x14000dff6", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000dff6", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000dffb", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14000e000", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14000e005", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000e009", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000e00a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000952c", + "name": "", + "blocks": [ + { + "address": "0x14000952c", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000952c", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140009054" + } + ], + "successors": [ + "0x140009054" + ] + }, + { + "address": "0x140009054", + "size": 22, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009054", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140009059", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x14000905e", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x140009063", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140009064", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140009066", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140009068", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x50" + }, + { + "address": "0x14000906c", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x14000906f", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, r9" + }, + { + "address": "0x140009072", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r8" + }, + { + "address": "0x140009075", + "size": 3, + "mnemonic": "mov", + "operands": "r15, r8" + }, + { + "address": "0x140009078", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rdx" + }, + { + "address": "0x14000907b", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a704" + }, + { + "address": "0x140009080", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140009085", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x90]" + }, + { + "address": "0x14000908d", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0x80000029" + }, + { + "address": "0x140009092", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0x1fffffff" + }, + { + "address": "0x140009097", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x80000026" + }, + { + "address": "0x14000909d", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rax + 0x40], 0" + }, + { + "address": "0x1400090a1", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400090d9" + }, + { + "address": "0x1400090a3", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rdi], 0xe06d7363" + }, + { + "address": "0x1400090a9", + "size": 2, + "mnemonic": "je", + "operands": "0x1400090d9" + } + ], + "successors": [ + "0x1400090d9", + "0x1400090ab" + ] + }, + { + "address": "0x1400090d9", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400090d9", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [rdi + 4], 0x66" + }, + { + "address": "0x1400090dd", + "size": 6, + "mnemonic": "je", + "operands": "0x140009172" + } + ], + "successors": [ + "0x140009172", + "0x1400090e3" + ] + }, + { + "address": "0x1400090ab", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400090ab", + "size": 2, + "mnemonic": "cmp", + "operands": "dword ptr [rdi], edx" + }, + { + "address": "0x1400090ad", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400090bf" + }, + { + "address": "0x1400090af", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rdi + 0x18], 0xf" + }, + { + "address": "0x1400090b3", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400090c4" + }, + { + "address": "0x1400090b5", + "size": 8, + "mnemonic": "cmp", + "operands": "qword ptr [rdi + 0x60], 0x19930520" + }, + { + "address": "0x1400090bd", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400090c2" + } + ], + "successors": [ + "0x1400090c2" + ] + }, + { + "address": "0x140009172", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009172", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rbx + 0xc], 0" + }, + { + "address": "0x140009176", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400091b3" + }, + { + "address": "0x140009178", + "size": 2, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbx]" + }, + { + "address": "0x14000917a", + "size": 2, + "mnemonic": "and", + "operands": "eax, ecx" + }, + { + "address": "0x14000917c", + "size": 5, + "mnemonic": "cmp", + "operands": "eax, 0x19930521" + }, + { + "address": "0x140009181", + "size": 2, + "mnemonic": "jb", + "operands": "0x14000919a" + } + ], + "successors": [ + "0x14000919a", + "0x140009183" + ] + }, + { + "address": "0x1400090e3", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400090e3", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rbx + 4], 0" + }, + { + "address": "0x1400090e7", + "size": 6, + "mnemonic": "je", + "operands": "0x14000925c" + } + ], + "successors": [ + "0x14000925c", + "0x1400090ed" + ] + }, + { + "address": "0x1400090c2", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400090c2", + "size": 2, + "mnemonic": "je", + "operands": "0x1400090d9" + } + ], + "successors": [ + "0x1400090d9", + "0x1400090c4" + ] + }, + { + "address": "0x14000919a", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000919a", + "size": 2, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbx]" + }, + { + "address": "0x14000919c", + "size": 2, + "mnemonic": "and", + "operands": "eax, ecx" + }, + { + "address": "0x14000919e", + "size": 5, + "mnemonic": "cmp", + "operands": "eax, 0x19930522" + }, + { + "address": "0x1400091a3", + "size": 6, + "mnemonic": "jb", + "operands": "0x14000925c" + } + ], + "successors": [ + "0x14000925c", + "0x1400091a9" + ] + }, + { + "address": "0x140009183", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009183", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbp, dword ptr [rbx + 0x20]" + }, + { + "address": "0x140009187", + "size": 2, + "mnemonic": "test", + "operands": "ebp, ebp" + }, + { + "address": "0x140009189", + "size": 2, + "mnemonic": "je", + "operands": "0x14000919a" + } + ], + "successors": [ + "0x14000919a", + "0x14000918b" + ] + }, + { + "address": "0x14000925c", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000925c", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 1" + }, + { + "address": "0x140009261", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x50]" + }, + { + "address": "0x140009266", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x20]" + }, + { + "address": "0x14000926a", + "size": 4, + "mnemonic": "mov", + "operands": "rbp, qword ptr [r11 + 0x28]" + }, + { + "address": "0x14000926e", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x30]" + }, + { + "address": "0x140009272", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x140009275", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140009277", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140009279", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000927a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400090ed", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400090ed", + "size": 8, + "mnemonic": "cmp", + "operands": "dword ptr [rsp + 0x98], 0" + }, + { + "address": "0x1400090f5", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000925c" + }, + { + "address": "0x1400090fb", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [rdi + 4], 0x20" + }, + { + "address": "0x1400090ff", + "size": 2, + "mnemonic": "je", + "operands": "0x14000915f" + } + ], + "successors": [ + "0x14000915f", + "0x140009101" + ] + }, + { + "address": "0x1400090c4", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400090c4", + "size": 2, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbx]" + }, + { + "address": "0x1400090c6", + "size": 2, + "mnemonic": "and", + "operands": "eax, ecx" + }, + { + "address": "0x1400090c8", + "size": 5, + "mnemonic": "cmp", + "operands": "eax, 0x19930522" + }, + { + "address": "0x1400090cd", + "size": 2, + "mnemonic": "jb", + "operands": "0x1400090d9" + } + ], + "successors": [ + "0x1400090d9", + "0x1400090cf" + ] + }, + { + "address": "0x1400091a9", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400091a9", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [rbx + 0x24], 4" + }, + { + "address": "0x1400091ad", + "size": 6, + "mnemonic": "je", + "operands": "0x14000925c" + } + ], + "successors": [ + "0x14000925c", + "0x1400091b3" + ] + }, + { + "address": "0x14000918b", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000918b", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140009190", + "size": 3, + "mnemonic": "add", + "operands": "rax, rbp" + }, + { + "address": "0x140009193", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400091b3" + }, + { + "address": "0x140009195", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0x1fffffff" + }, + { + "address": "0x14000919a", + "size": 2, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbx]" + }, + { + "address": "0x14000919c", + "size": 2, + "mnemonic": "and", + "operands": "eax, ecx" + }, + { + "address": "0x14000919e", + "size": 5, + "mnemonic": "cmp", + "operands": "eax, 0x19930522" + }, + { + "address": "0x1400091a3", + "size": 6, + "mnemonic": "jb", + "operands": "0x14000925c" + } + ], + "successors": [ + "0x14000925c", + "0x1400091a9" + ] + }, + { + "address": "0x14000915f", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000915f", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rbx" + }, + { + "address": "0x140009162", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x140009165", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r14" + }, + { + "address": "0x140009168", + "size": 5, + "mnemonic": "call", + "operands": "0x1400064ac" + }, + { + "address": "0x14000916d", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000925c" + } + ], + "successors": [ + "0x14000925c" + ] + }, + { + "address": "0x140009101", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009101", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rdi], r8d" + }, + { + "address": "0x140009104", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000913d" + }, + { + "address": "0x140009106", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsi + 0x20]" + }, + { + "address": "0x14000910a", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x14000910d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140009110", + "size": 5, + "mnemonic": "call", + "operands": "0x1400075e8" + }, + { + "address": "0x140009115", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, -1" + }, + { + "address": "0x140009118", + "size": 6, + "mnemonic": "jl", + "operands": "0x14000927b" + } + ], + "successors": [ + "0x14000927b", + "0x14000911e" + ] + }, + { + "address": "0x1400090cf", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400090cf", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [rbx + 0x24], 1" + }, + { + "address": "0x1400090d3", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000925c" + }, + { + "address": "0x1400090d9", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [rdi + 4], 0x66" + }, + { + "address": "0x1400090dd", + "size": 6, + "mnemonic": "je", + "operands": "0x140009172" + } + ], + "successors": [ + "0x140009172", + "0x1400090e3" + ] + }, + { + "address": "0x1400091b3", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400091b3", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rdi], 0xe06d7363" + }, + { + "address": "0x1400091b9", + "size": 2, + "mnemonic": "jne", + "operands": "0x140009223" + }, + { + "address": "0x1400091bb", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rdi + 0x18], 3" + }, + { + "address": "0x1400091bf", + "size": 2, + "mnemonic": "jb", + "operands": "0x140009223" + } + ], + "successors": [ + "0x140009223", + "0x1400091c1" + ] + }, + { + "address": "0x14000927b", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000927b", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140009280", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000911e", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000911e", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, dword ptr [rbx + 4]" + }, + { + "address": "0x140009121", + "size": 6, + "mnemonic": "jge", + "operands": "0x14000927b" + }, + { + "address": "0x140009127", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, eax" + }, + { + "address": "0x14000912a", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r14" + }, + { + "address": "0x14000912d", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x140009130", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rbx" + }, + { + "address": "0x140009133", + "size": 5, + "mnemonic": "call", + "operands": "0x140009dc4" + }, + { + "address": "0x140009138", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000925c" + } + ], + "successors": [ + "0x14000925c" + ] + }, + { + "address": "0x140009223", + "size": 22, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140009223", + "size": 8, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0xa0]" + }, + { + "address": "0x14000922b", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rsi" + }, + { + "address": "0x14000922e", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], rax" + }, + { + "address": "0x140009233", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r15" + }, + { + "address": "0x140009236", + "size": 7, + "mnemonic": "mov", + "operands": "eax, dword ptr [rsp + 0x98]" + }, + { + "address": "0x14000923d", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r14" + }, + { + "address": "0x140009240", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x30], eax" + }, + { + "address": "0x140009244", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140009247", + "size": 7, + "mnemonic": "mov", + "operands": "al, byte ptr [rsp + 0xa8]" + }, + { + "address": "0x14000924e", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x28], al" + }, + { + "address": "0x140009252", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rbx" + }, + { + "address": "0x140009257", + "size": 5, + "mnemonic": "call", + "operands": "0x140007e60" + }, + { + "address": "0x14000925c", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 1" + }, + { + "address": "0x140009261", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x50]" + }, + { + "address": "0x140009266", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x20]" + }, + { + "address": "0x14000926a", + "size": 4, + "mnemonic": "mov", + "operands": "rbp, qword ptr [r11 + 0x28]" + }, + { + "address": "0x14000926e", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x30]" + }, + { + "address": "0x140009272", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x140009275", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140009277", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140009279", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000927a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400091c1", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400091c1", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rdi + 0x20], 0x19930522" + }, + { + "address": "0x1400091c8", + "size": 2, + "mnemonic": "jbe", + "operands": "0x140009223" + }, + { + "address": "0x1400091ca", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdi + 0x30]" + }, + { + "address": "0x1400091ce", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbp, dword ptr [rax + 8]" + }, + { + "address": "0x1400091d2", + "size": 2, + "mnemonic": "test", + "operands": "ebp, ebp" + }, + { + "address": "0x1400091d4", + "size": 2, + "mnemonic": "je", + "operands": "0x140009223" + } + ], + "successors": [ + "0x140009223", + "0x1400091d6" + ] + }, + { + "address": "0x1400091d6", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400091d6", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x1400091db", + "size": 3, + "mnemonic": "mov", + "operands": "r10, rax" + }, + { + "address": "0x1400091de", + "size": 3, + "mnemonic": "add", + "operands": "r10, rbp" + }, + { + "address": "0x1400091e1", + "size": 2, + "mnemonic": "je", + "operands": "0x140009223" + } + ], + "successors": [ + "0x140009223", + "0x1400091e3" + ] + }, + { + "address": "0x1400091e3", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400091e3", + "size": 8, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rsp + 0xa8]" + }, + { + "address": "0x1400091eb", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rsi" + }, + { + "address": "0x1400091ee", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x38], ecx" + }, + { + "address": "0x1400091f2", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r15" + }, + { + "address": "0x1400091f5", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0xa0]" + }, + { + "address": "0x1400091fd", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r14" + }, + { + "address": "0x140009200", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rcx" + }, + { + "address": "0x140009205", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r10" + }, + { + "address": "0x140009208", + "size": 7, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rsp + 0x98]" + }, + { + "address": "0x14000920f", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], ecx" + }, + { + "address": "0x140009213", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140009216", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rbx" + }, + { + "address": "0x14000921b", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1709f]" + }, + { + "address": "0x140009221", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140009261" + } + ], + "successors": [ + "0x140009261" + ] + }, + { + "address": "0x140009261", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140009261", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x50]" + }, + { + "address": "0x140009266", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x20]" + }, + { + "address": "0x14000926a", + "size": 4, + "mnemonic": "mov", + "operands": "rbp, qword ptr [r11 + 0x28]" + }, + { + "address": "0x14000926e", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x30]" + }, + { + "address": "0x140009272", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x140009275", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140009277", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140009279", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000927a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140009534", + "name": "", + "blocks": [ + { + "address": "0x140009534", + "size": 18, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140009534", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140009536", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x14000953a", + "size": 7, + "mnemonic": "mov", + "operands": "al, byte ptr [rsp + 0x88]" + }, + { + "address": "0x140009541", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x38], al" + }, + { + "address": "0x140009545", + "size": 8, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x80]" + }, + { + "address": "0x14000954d", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rax" + }, + { + "address": "0x140009552", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [rsp + 0x78]" + }, + { + "address": "0x140009556", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], eax" + }, + { + "address": "0x14000955a", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x70]" + }, + { + "address": "0x14000955f", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x140009564", + "size": 5, + "mnemonic": "call", + "operands": "0x140009284" + }, + { + "address": "0x140009569", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, eax" + }, + { + "address": "0x14000956b", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140009570", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x78], 0xfffffffe" + }, + { + "address": "0x140009577", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ebx" + }, + { + "address": "0x140009579", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x40" + }, + { + "address": "0x14000957d", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000957e", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140009cfc", + "name": "", + "blocks": [ + { + "address": "0x140009cfc", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009cfc", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140009cfe", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140009d02", + "size": 3, + "mnemonic": "mov", + "operands": "r9, qword ptr [rcx]" + }, + { + "address": "0x140009d05", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r8" + }, + { + "address": "0x140009d08", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0xe06d7363" + }, + { + "address": "0x140009d0d", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [r8], 0" + }, + { + "address": "0x140009d14", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [r9], ecx" + }, + { + "address": "0x140009d17", + "size": 2, + "mnemonic": "jne", + "operands": "0x140009d89" + }, + { + "address": "0x140009d19", + "size": 5, + "mnemonic": "cmp", + "operands": "dword ptr [r9 + 0x18], 4" + }, + { + "address": "0x140009d1e", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x19930520" + }, + { + "address": "0x140009d24", + "size": 2, + "mnemonic": "jne", + "operands": "0x140009d49" + }, + { + "address": "0x140009d26", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r9 + 0x20]" + }, + { + "address": "0x140009d2a", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, r8d" + }, + { + "address": "0x140009d2d", + "size": 2, + "mnemonic": "je", + "operands": "0x140009d39" + } + ], + "successors": [ + "0x140009d39", + "0x140009d2f" + ] + }, + { + "address": "0x140009d39", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009d39", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdx + 0x28]" + }, + { + "address": "0x140009d3d", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [r9 + 0x28], rax" + }, + { + "address": "0x140009d41", + "size": 2, + "mnemonic": "jne", + "operands": "0x140009d49" + }, + { + "address": "0x140009d43", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rbx], 1" + }, + { + "address": "0x140009d49", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [r9], ecx" + }, + { + "address": "0x140009d4c", + "size": 2, + "mnemonic": "jne", + "operands": "0x140009d89" + }, + { + "address": "0x140009d4e", + "size": 5, + "mnemonic": "cmp", + "operands": "dword ptr [r9 + 0x18], 4" + }, + { + "address": "0x140009d53", + "size": 2, + "mnemonic": "jne", + "operands": "0x140009d89" + }, + { + "address": "0x140009d55", + "size": 4, + "mnemonic": "mov", + "operands": "ecx, dword ptr [r9 + 0x20]" + }, + { + "address": "0x140009d59", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, r8d" + }, + { + "address": "0x140009d5c", + "size": 2, + "mnemonic": "je", + "operands": "0x140009d69" + } + ], + "successors": [ + "0x140009d69", + "0x140009d5e" + ] + }, + { + "address": "0x140009d2f", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009d2f", + "size": 5, + "mnemonic": "add", + "operands": "eax, 0xe66cfadf" + }, + { + "address": "0x140009d34", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x140009d37", + "size": 2, + "mnemonic": "ja", + "operands": "0x140009d49" + } + ], + "successors": [ + "0x140009d49", + "0x140009d39" + ] + }, + { + "address": "0x140009d69", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009d69", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [r9 + 0x30], 0" + }, + { + "address": "0x140009d6e", + "size": 2, + "mnemonic": "jne", + "operands": "0x140009d89" + }, + { + "address": "0x140009d70", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140009d75", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x40], 1" + }, + { + "address": "0x140009d7c", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 1" + }, + { + "address": "0x140009d81", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rbx], 1" + }, + { + "address": "0x140009d87", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140009d8b" + } + ], + "successors": [ + "0x140009d8b" + ] + }, + { + "address": "0x140009d5e", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009d5e", + "size": 6, + "mnemonic": "add", + "operands": "ecx, 0xe66cfadf" + }, + { + "address": "0x140009d64", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, 1" + }, + { + "address": "0x140009d67", + "size": 2, + "mnemonic": "ja", + "operands": "0x140009d89" + } + ], + "successors": [ + "0x140009d89", + "0x140009d69" + ] + }, + { + "address": "0x140009d49", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009d49", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [r9], ecx" + }, + { + "address": "0x140009d4c", + "size": 2, + "mnemonic": "jne", + "operands": "0x140009d89" + }, + { + "address": "0x140009d4e", + "size": 5, + "mnemonic": "cmp", + "operands": "dword ptr [r9 + 0x18], 4" + }, + { + "address": "0x140009d53", + "size": 2, + "mnemonic": "jne", + "operands": "0x140009d89" + }, + { + "address": "0x140009d55", + "size": 4, + "mnemonic": "mov", + "operands": "ecx, dword ptr [r9 + 0x20]" + }, + { + "address": "0x140009d59", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, r8d" + }, + { + "address": "0x140009d5c", + "size": 2, + "mnemonic": "je", + "operands": "0x140009d69" + } + ], + "successors": [ + "0x140009d69", + "0x140009d5e" + ] + }, + { + "address": "0x140009d8b", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140009d8b", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140009d8f", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140009d90", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140009d89", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140009d89", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140009d8b", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140009d8f", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140009d90", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140006d54", + "name": "", + "blocks": [ + { + "address": "0x140006d54", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006d54", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140006d59", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140006d5a", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140006d5e", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x140006d61", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140006d66", + "size": 4, + "mnemonic": "cmp", + "operands": "rdi, qword ptr [rax + 0x58]" + }, + { + "address": "0x140006d6a", + "size": 2, + "mnemonic": "jne", + "operands": "0x140006da1" + }, + { + "address": "0x140006d6c", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140006d71", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rax + 0x58]" + }, + { + "address": "0x140006d75", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x140006d78", + "size": 2, + "mnemonic": "je", + "operands": "0x140006da1" + } + ], + "successors": [ + "0x140006da1", + "0x140006d7a" + ] + }, + { + "address": "0x140006da1", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006da1", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140006da6", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140006d7a", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006d7a", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rdx + 8]" + }, + { + "address": "0x140006d7e", + "size": 3, + "mnemonic": "cmp", + "operands": "rdi, rdx" + }, + { + "address": "0x140006d81", + "size": 2, + "mnemonic": "je", + "operands": "0x140006d8d" + } + ], + "successors": [ + "0x140006d8d", + "0x140006d83" + ] + }, + { + "address": "0x140006d8d", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140006d8d", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140006d92", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x58], rbx" + }, + { + "address": "0x140006d96", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140006d9b", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140006d9f", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140006da0", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140006d83", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006d83", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x140006d86", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x140006d89", + "size": 2, + "mnemonic": "je", + "operands": "0x140006da1" + } + ], + "successors": [ + "0x140006da1", + "0x140006d8b" + ] + }, + { + "address": "0x140006d8b", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006d8b", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140006d7a" + } + ], + "successors": [ + "0x140006d7a" + ] + } + ] + }, + { + "address": "0x140007010", + "name": "", + "blocks": [ + { + "address": "0x140007010", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007010", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140007012", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140007016", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140007019", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14000701e", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rax + 0x58]" + }, + { + "address": "0x140007022", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000702d" + } + ], + "successors": [ + "0x14000702d" + ] + }, + { + "address": "0x14000702d", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000702d", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x140007030", + "size": 2, + "mnemonic": "jne", + "operands": "0x140007024" + }, + { + "address": "0x140007032", + "size": 3, + "mnemonic": "lea", + "operands": "eax, [rdx + 1]" + }, + { + "address": "0x140007035", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140007039", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000703a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140009d94", + "name": "", + "blocks": [ + { + "address": "0x140009d94", + "size": 16, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140009d94", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140009d99", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140009d9a", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140009d9e", + "size": 3, + "mnemonic": "mov", + "operands": "edi, r8d" + }, + { + "address": "0x140009da1", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r9" + }, + { + "address": "0x140009da4", + "size": 5, + "mnemonic": "call", + "operands": "0x140009cfc" + }, + { + "address": "0x140009da9", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, eax" + }, + { + "address": "0x140009dab", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140009dad", + "size": 2, + "mnemonic": "jne", + "operands": "0x140009db7" + }, + { + "address": "0x140009daf", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140009db4", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x78], edi" + }, + { + "address": "0x140009db7", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ebx" + }, + { + "address": "0x140009db9", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140009dbe", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140009dc2", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140009dc3", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140007064", + "name": "", + "blocks": [ + { + "address": "0x140007064", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007064", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140007069", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000706a", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000706e", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rcx]" + }, + { + "address": "0x140007071", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140007074", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rdi], 0xe0434352" + }, + { + "address": "0x14000707a", + "size": 2, + "mnemonic": "je", + "operands": "0x14000708e" + } + ], + "successors": [ + "0x14000708e", + "0x14000707c" + ] + }, + { + "address": "0x14000708e", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000708e", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140007093", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rax + 0x30], 0" + }, + { + "address": "0x140007097", + "size": 2, + "mnemonic": "jle", + "operands": "0x1400070a1" + }, + { + "address": "0x140007099", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14000709e", + "size": 3, + "mnemonic": "dec", + "operands": "dword ptr [rax + 0x30]" + }, + { + "address": "0x1400070a1", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x1400070a6", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x1400070a8", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400070ac", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400070ad", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000707c", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000707c", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rdi], 0xe0434f4d" + }, + { + "address": "0x140007082", + "size": 2, + "mnemonic": "je", + "operands": "0x14000708e" + } + ], + "successors": [ + "0x14000708e", + "0x140007084" + ] + }, + { + "address": "0x140007084", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007084", + "size": 6, + "mnemonic": "cmp", + "operands": "dword ptr [rdi], 0xe06d7363" + }, + { + "address": "0x14000708a", + "size": 2, + "mnemonic": "je", + "operands": "0x1400070ae" + } + ], + "successors": [ + "0x1400070ae", + "0x14000708c" + ] + }, + { + "address": "0x1400070ae", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400070ae", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x1400070b3", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x20], rdi" + }, + { + "address": "0x1400070b7", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rbx + 8]" + }, + { + "address": "0x1400070bb", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x1400070c0", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x28], rbx" + }, + { + "address": "0x1400070c4", + "size": 5, + "mnemonic": "call", + "operands": "0x140010b70" + }, + { + "address": "0x1400070c9", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000708c", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000708c", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400070a1" + } + ], + "successors": [ + "0x1400070a1" + ] + }, + { + "address": "0x1400070a1", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400070a1", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x1400070a6", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x1400070a8", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400070ac", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400070ad", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000b204", + "name": "", + "blocks": [ + ] + }, + { + "address": "0x14000ca74", + "name": "", + "blocks": [ + ] + }, + { + "address": "0x14000a73c", + "name": "", + "blocks": [ + { + "address": "0x14000a73c", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a73c", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x14000a73e", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a742", + "size": 2, + "mnemonic": "xor", + "operands": "ebx, ebx" + }, + { + "address": "0x14000a744", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x2861d]" + }, + { + "address": "0x14000a74b", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x14000a74e", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbx + rbx*4]" + }, + { + "address": "0x14000a752", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rdx + rcx*8]" + }, + { + "address": "0x14000a756", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0xfa0" + }, + { + "address": "0x14000a75b", + "size": 5, + "mnemonic": "call", + "operands": "0x14000aa38" + }, + { + "address": "0x14000a760", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000a762", + "size": 2, + "mnemonic": "je", + "operands": "0x14000a775" + } + ], + "successors": [ + "0x14000a775", + "0x14000a764" + ] + }, + { + "address": "0x14000a775", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000a775", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a784" + }, + { + "address": "0x14000a77a", + "size": 2, + "mnemonic": "xor", + "operands": "al, al" + }, + { + "address": "0x14000a77c", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a780", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000a781", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000a764", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a764", + "size": 6, + "mnemonic": "inc", + "operands": "dword ptr [rip + 0x28626]" + }, + { + "address": "0x14000a76a", + "size": 2, + "mnemonic": "inc", + "operands": "ebx" + }, + { + "address": "0x14000a76c", + "size": 3, + "mnemonic": "cmp", + "operands": "ebx, 1" + }, + { + "address": "0x14000a76f", + "size": 2, + "mnemonic": "jb", + "operands": "0x14000a744" + } + ], + "successors": [ + "0x14000a744", + "0x14000a771" + ] + }, + { + "address": "0x14000a744", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a744", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x2861d]" + }, + { + "address": "0x14000a74b", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x14000a74e", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbx + rbx*4]" + }, + { + "address": "0x14000a752", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rdx + rcx*8]" + }, + { + "address": "0x14000a756", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0xfa0" + }, + { + "address": "0x14000a75b", + "size": 5, + "mnemonic": "call", + "operands": "0x14000aa38" + }, + { + "address": "0x14000a760", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000a762", + "size": 2, + "mnemonic": "je", + "operands": "0x14000a775" + } + ], + "successors": [ + "0x14000a775", + "0x14000a764" + ] + }, + { + "address": "0x14000a771", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a771", + "size": 2, + "mnemonic": "mov", + "operands": "al, 1" + }, + { + "address": "0x14000a773", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000a77c" + } + ], + "successors": [ + "0x14000a77c" + ] + }, + { + "address": "0x14000a77c", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000a77c", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a780", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000a781", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000b74c", + "name": "", + "blocks": [ + { + "address": "0x14000b74c", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b74c", + "size": 2, + "mnemonic": "mov", + "operands": "cl, 1" + }, + { + "address": "0x14000b74e", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000b58c" + } + ], + "successors": [ + "0x14000b58c" + ] + } + ] + }, + { + "address": "0x140007514", + "name": "", + "blocks": [ + { + "address": "0x140007514", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007514", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x140007518", + "size": 6, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rip + 0x29ba2]" + }, + { + "address": "0x14000751e", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, -1" + }, + { + "address": "0x140007521", + "size": 2, + "mnemonic": "je", + "operands": "0x140007532" + } + ], + "successors": [ + "0x140007532", + "0x140007523" + ] + }, + { + "address": "0x140007532", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140007532", + "size": 2, + "mnemonic": "mov", + "operands": "al, 1" + }, + { + "address": "0x140007534", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x140007538", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140007523", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140007523", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a954" + }, + { + "address": "0x140007528", + "size": 10, + "mnemonic": "mov", + "operands": "dword ptr [rip + 0x29b8e], 0xffffffff" + }, + { + "address": "0x140007532", + "size": 2, + "mnemonic": "mov", + "operands": "al, 1" + }, + { + "address": "0x140007534", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x140007538", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000a784", + "name": "", + "blocks": [ + { + "address": "0x14000a784", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a784", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x14000a786", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a78a", + "size": 6, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rip + 0x28600]" + }, + { + "address": "0x14000a790", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000a7af" + } + ], + "successors": [ + "0x14000a7af" + ] + }, + { + "address": "0x14000a7af", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000a7af", + "size": 2, + "mnemonic": "test", + "operands": "ebx, ebx" + }, + { + "address": "0x14000a7b1", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000a792" + }, + { + "address": "0x14000a7b3", + "size": 2, + "mnemonic": "mov", + "operands": "al, 1" + }, + { + "address": "0x14000a7b5", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a7b9", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000a7ba", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000ca20", + "name": "", + "blocks": [ + { + "address": "0x14000ca20", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ca20", + "size": 3, + "mnemonic": "movsxd", + "operands": "rax, ecx" + }, + { + "address": "0x14000ca23", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + rax*4]" + }, + { + "address": "0x14000ca27", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x263d2]" + }, + { + "address": "0x14000ca2e", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + rcx*8]" + }, + { + "address": "0x14000ca32", + "size": 7, + "mnemonic": "jmp", + "operands": "qword ptr [rip + 0x135d7]" + } + ], + "successors": [ + "0x140020010" + ] + }, + { + "address": "0x140020010", + "size": 0, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000e96c", + "name": "", + "blocks": [ + { + "address": "0x14000e96c", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000e96c", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x14000e96e", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000e972", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14000e975", + "size": 7, + "mnemonic": "cmp", + "operands": "byte ptr [rip + 0x2483c], 0" + }, + { + "address": "0x14000e97c", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000ea20" + }, + { + "address": "0x14000e982", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 1" + }, + { + "address": "0x14000e987", + "size": 6, + "mnemonic": "xchg", + "operands": "dword ptr [rip + 0x2481b], eax" + }, + { + "address": "0x14000e98d", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x14000e990", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rax]" + }, + { + "address": "0x14000e992", + "size": 2, + "mnemonic": "test", + "operands": "ecx, ecx" + }, + { + "address": "0x14000e994", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000e9c9" + }, + { + "address": "0x14000e996", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x226a3]" + }, + { + "address": "0x14000e99d", + "size": 7, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rip + 0x2480c]" + }, + { + "address": "0x14000e9a4", + "size": 3, + "mnemonic": "cmp", + "operands": "rdx, rax" + }, + { + "address": "0x14000e9a7", + "size": 2, + "mnemonic": "je", + "operands": "0x14000e9c0" + } + ], + "successors": [ + "0x14000e9c0", + "0x14000e9a9" + ] + }, + { + "address": "0x14000e9c0", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000e9c0", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x24839]" + }, + { + "address": "0x14000e9c7", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000e9d5" + } + ], + "successors": [ + "0x14000e9d5" + ] + }, + { + "address": "0x14000e9a9", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000e9a9", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, eax" + }, + { + "address": "0x14000e9ab", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0x3f" + }, + { + "address": "0x14000e9ae", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rdx" + }, + { + "address": "0x14000e9b1", + "size": 3, + "mnemonic": "ror", + "operands": "rax, cl" + }, + { + "address": "0x14000e9b4", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x14000e9b7", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000e9b9", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14000e9bb", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3a0" + }, + { + "address": "0x14000e9c0", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x24839]" + }, + { + "address": "0x14000e9c7", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000e9d5" + } + ], + "successors": [ + "0x14000e9d5" + ] + }, + { + "address": "0x14000e9d5", + "size": 20, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000e9d5", + "size": 5, + "mnemonic": "call", + "operands": "0x140010944" + }, + { + "address": "0x14000e9da", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14000e9db", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx]" + }, + { + "address": "0x14000e9de", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rax], 0" + }, + { + "address": "0x14000e9e1", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000e9f6" + }, + { + "address": "0x14000e9e3", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x119c6]" + }, + { + "address": "0x14000e9ea", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x1199f]" + }, + { + "address": "0x14000e9f1", + "size": 5, + "mnemonic": "call", + "operands": "0x14000e8c0" + }, + { + "address": "0x14000e9f6", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x119c3]" + }, + { + "address": "0x14000e9fd", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x119b4]" + }, + { + "address": "0x14000ea04", + "size": 5, + "mnemonic": "call", + "operands": "0x14000e8c0" + }, + { + "address": "0x14000ea09", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx + 8]" + }, + { + "address": "0x14000ea0d", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rax], 0" + }, + { + "address": "0x14000ea10", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000ea20" + }, + { + "address": "0x14000ea12", + "size": 7, + "mnemonic": "mov", + "operands": "byte ptr [rip + 0x2479f], 1" + }, + { + "address": "0x14000ea19", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx + 0x10]" + }, + { + "address": "0x14000ea1d", + "size": 3, + "mnemonic": "mov", + "operands": "byte ptr [rax], 1" + }, + { + "address": "0x14000ea20", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000ea24", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000ea25", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400191a8", + "name": "", + "blocks": [ + { + "address": "0x1400191a8", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400191a8", + "size": 9, + "mnemonic": "mov", + "operands": "rax, qword ptr gs:[0x30]" + }, + { + "address": "0x1400191b1", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax + 0x60]" + }, + { + "address": "0x1400191b5", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0x20]" + }, + { + "address": "0x1400191b9", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rax + 8]" + }, + { + "address": "0x1400191bc", + "size": 3, + "mnemonic": "shr", + "operands": "eax, 0x1f" + }, + { + "address": "0x1400191bf", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140011db4", + "name": "", + "blocks": [ + { + "address": "0x140011db4", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011db4", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140011db6", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140011dba", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x2430f]" + }, + { + "address": "0x140011dc1", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140011dc4", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, -1" + }, + { + "address": "0x140011dc8", + "size": 2, + "mnemonic": "je", + "operands": "0x140011e05" + } + ], + "successors": [ + "0x140011e05", + "0x140011dca" + ] + }, + { + "address": "0x140011e05", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140011e05", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0xc0000225" + }, + { + "address": "0x140011e0a", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140011e0e", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140011e0f", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140011dca", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011dca", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140011dcd", + "size": 2, + "mnemonic": "jne", + "operands": "0x140011df1" + }, + { + "address": "0x140011dcf", + "size": 7, + "mnemonic": "lea", + "operands": "r9, [rip + 0x14c02]" + }, + { + "address": "0x140011dd6", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip + 0x14bf7]" + }, + { + "address": "0x140011ddd", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x14bf4]" + }, + { + "address": "0x140011de4", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rax + 0x1a]" + }, + { + "address": "0x140011de7", + "size": 5, + "mnemonic": "call", + "operands": "0x140011c00" + }, + { + "address": "0x140011dec", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140011def", + "size": 2, + "mnemonic": "je", + "operands": "0x140011e05" + } + ], + "successors": [ + "0x140011e05", + "0x140011df1" + ] + }, + { + "address": "0x140011df1", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011df1", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x140011df4", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, 0xfffffffffffffffa" + }, + { + "address": "0x140011dfb", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140011dff", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140011e00", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14001e3a0" + } + ], + "successors": [ + "0x14001e3a0" + ] + } + ] + }, + { + "address": "0x140001ab0", + "name": "", + "blocks": [ + { + "address": "0x140001ab0", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001ab0", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140001ab5", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140001ab6", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140001aba", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rcx], rdx" + }, + { + "address": "0x140001abd", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140001ac0", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdx]" + }, + { + "address": "0x140001ac3", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x140001ac6", + "size": 4, + "mnemonic": "movsxd", + "operands": "r8, dword ptr [rax + 4]" + }, + { + "address": "0x140001aca", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r8 + rdx + 0x48]" + }, + { + "address": "0x140001acf", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140001ad2", + "size": 2, + "mnemonic": "je", + "operands": "0x140001ada" + } + ], + "successors": [ + "0x140001ada", + "0x140001ad4" + ] + }, + { + "address": "0x140001ada", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001ada", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdi]" + }, + { + "address": "0x140001add", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax + 4]" + }, + { + "address": "0x140001ae1", + "size": 5, + "mnemonic": "cmp", + "operands": "dword ptr [rcx + rdi + 0x10], 0" + }, + { + "address": "0x140001ae6", + "size": 2, + "mnemonic": "je", + "operands": "0x140001afa" + } + ], + "successors": [ + "0x140001afa", + "0x140001ae8" + ] + }, + { + "address": "0x140001ad4", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001ad4", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x140001ad7", + "size": 3, + "mnemonic": "call", + "operands": "qword ptr [rax + 8]" + }, + { + "address": "0x140001ada", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdi]" + }, + { + "address": "0x140001add", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax + 4]" + }, + { + "address": "0x140001ae1", + "size": 5, + "mnemonic": "cmp", + "operands": "dword ptr [rcx + rdi + 0x10], 0" + }, + { + "address": "0x140001ae6", + "size": 2, + "mnemonic": "je", + "operands": "0x140001afa" + } + ], + "successors": [ + "0x140001afa", + "0x140001ae8" + ] + }, + { + "address": "0x140001afa", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001afa", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + rdi + 0x50]" + }, + { + "address": "0x140001aff", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140001b02", + "size": 2, + "mnemonic": "je", + "operands": "0x140001b2e" + } + ], + "successors": [ + "0x140001b2e", + "0x140001b04" + ] + }, + { + "address": "0x140001ae8", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140001ae8", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbx + 8], 0" + }, + { + "address": "0x140001aec", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140001aef", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140001af4", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140001af8", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140001af9", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140001b2e", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140001b2e", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbx + 8], 1" + }, + { + "address": "0x140001b32", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140001b35", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140001b3a", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140001b3e", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140001b3f", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140001b04", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001b04", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, rdi" + }, + { + "address": "0x140001b07", + "size": 2, + "mnemonic": "je", + "operands": "0x140001b2e" + } + ], + "successors": [ + "0x140001b2e", + "0x140001b09" + ] + }, + { + "address": "0x140001b09", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140001b09", + "size": 5, + "mnemonic": "call", + "operands": "0x140002000" + }, + { + "address": "0x140001b0e", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdi]" + }, + { + "address": "0x140001b11", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rax + 4]" + }, + { + "address": "0x140001b15", + "size": 5, + "mnemonic": "cmp", + "operands": "dword ptr [rcx + rdi + 0x10], 0" + }, + { + "address": "0x140001b1a", + "size": 3, + "mnemonic": "sete", + "operands": "al" + }, + { + "address": "0x140001b1d", + "size": 3, + "mnemonic": "mov", + "operands": "byte ptr [rbx + 8], al" + }, + { + "address": "0x140001b20", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140001b23", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140001b28", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140001b2c", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140001b2d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000747c", + "name": "", + "blocks": [ + { + "address": "0x14000747c", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000747c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140007481", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140007482", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140007486", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x29c33], -1" + }, + { + "address": "0x14000748d", + "size": 2, + "mnemonic": "jne", + "operands": "0x140007493" + }, + { + "address": "0x14000748f", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140007491", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400074be" + } + ], + "successors": [ + "0x1400074be" + ] + }, + { + "address": "0x1400074be", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400074be", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x1400074c3", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400074c7", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400074c8", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400023ac", + "name": "", + "blocks": [ + { + "address": "0x1400023ac", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400023ac", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x48" + }, + { + "address": "0x1400023b0", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rcx" + }, + { + "address": "0x1400023b3", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x20]" + }, + { + "address": "0x1400023b8", + "size": 5, + "mnemonic": "call", + "operands": "0x1400022c0" + }, + { + "address": "0x1400023bd", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x2daac]" + }, + { + "address": "0x1400023c4", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x20]" + }, + { + "address": "0x1400023c9", + "size": 5, + "mnemonic": "call", + "operands": "0x140006198" + }, + { + "address": "0x1400023ce", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000d738", + "name": "", + "blocks": [ + { + "address": "0x14000d738", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d738", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000d73d", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rsi" + }, + { + "address": "0x14000d742", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rdi" + }, + { + "address": "0x14000d747", + "size": 2, + "mnemonic": "mov", + "operands": "edx, ecx" + }, + { + "address": "0x14000d749", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, 1" + }, + { + "address": "0x14000d74c", + "size": 2, + "mnemonic": "jb", + "operands": "0x14000d7bb" + } + ], + "successors": [ + "0x14000d7bb", + "0x14000d74e" + ] + }, + { + "address": "0x14000d7bb", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d7bb", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rdx - 0x13]" + }, + { + "address": "0x14000d7be", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, 0x11" + }, + { + "address": "0x14000d7c1", + "size": 2, + "mnemonic": "ja", + "operands": "0x14000d7e3" + } + ], + "successors": [ + "0x14000d7e3", + "0x14000d7c3" + ] + }, + { + "address": "0x14000d74e", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d74e", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, 0xd" + }, + { + "address": "0x14000d751", + "size": 2, + "mnemonic": "ja", + "operands": "0x14000d767" + } + ], + "successors": [ + "0x14000d767", + "0x14000d753" + ] + }, + { + "address": "0x14000d7e3", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000d7e3", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x16" + }, + { + "address": "0x14000d7e8", + "size": 6, + "mnemonic": "lea", + "operands": "ecx, [rdx - 0xbc]" + }, + { + "address": "0x14000d7ee", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, 0xe" + }, + { + "address": "0x14000d7f1", + "size": 3, + "mnemonic": "lea", + "operands": "edx, [rax - 0xe]" + }, + { + "address": "0x14000d7f4", + "size": 3, + "mnemonic": "cmovbe", + "operands": "eax, edx" + }, + { + "address": "0x14000d7f7", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 8]" + }, + { + "address": "0x14000d7fc", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x10]" + }, + { + "address": "0x14000d801", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x18]" + }, + { + "address": "0x14000d806", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000d7c3", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d7c3", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0xd" + }, + { + "address": "0x14000d7c8", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000d7f7" + } + ], + "successors": [ + "0x14000d7f7" + ] + }, + { + "address": "0x14000d767", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d767", + "size": 6, + "mnemonic": "cmp", + "operands": "edx, 0x718" + }, + { + "address": "0x14000d76d", + "size": 2, + "mnemonic": "ja", + "operands": "0x14000d7bb" + } + ], + "successors": [ + "0x14000d7bb", + "0x14000d76f" + ] + }, + { + "address": "0x14000d753", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d753", + "size": 3, + "mnemonic": "lea", + "operands": "eax, [rcx - 1]" + }, + { + "address": "0x14000d756", + "size": 7, + "mnemonic": "lea", + "operands": "r9, [rip + 0x17ee3]" + }, + { + "address": "0x14000d75d", + "size": 5, + "mnemonic": "mov", + "operands": "eax, dword ptr [r9 + rax*8 + 4]" + }, + { + "address": "0x14000d762", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000d7f7" + } + ], + "successors": [ + "0x14000d7f7" + ] + }, + { + "address": "0x14000d7f7", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000d7f7", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 8]" + }, + { + "address": "0x14000d7fc", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x10]" + }, + { + "address": "0x14000d801", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x18]" + }, + { + "address": "0x14000d806", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000d76f", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d76f", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0x2d" + }, + { + "address": "0x14000d774", + "size": 7, + "mnemonic": "lea", + "operands": "r9, [rip + 0x17ec5]" + }, + { + "address": "0x14000d77b", + "size": 2, + "mnemonic": "xor", + "operands": "esi, esi" + }, + { + "address": "0x14000d77d", + "size": 3, + "mnemonic": "mov", + "operands": "r10d, esi" + }, + { + "address": "0x14000d780", + "size": 3, + "mnemonic": "lea", + "operands": "edi, [rcx - 1]" + }, + { + "address": "0x14000d783", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rcx" + }, + { + "address": "0x14000d786", + "size": 3, + "mnemonic": "shr", + "operands": "r8, 1" + }, + { + "address": "0x14000d789", + "size": 2, + "mnemonic": "je", + "operands": "0x14000d7ca" + } + ], + "successors": [ + "0x14000d7ca", + "0x14000d78b" + ] + }, + { + "address": "0x14000d7ca", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d7ca", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14000d7cd", + "size": 2, + "mnemonic": "je", + "operands": "0x14000d7bb" + } + ], + "successors": [ + "0x14000d7bb", + "0x14000d7cf" + ] + }, + { + "address": "0x14000d78b", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d78b", + "size": 3, + "mnemonic": "test", + "operands": "cl, 1" + }, + { + "address": "0x14000d78e", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [r8 - 1]" + }, + { + "address": "0x14000d792", + "size": 4, + "mnemonic": "cmovne", + "operands": "rcx, r8" + }, + { + "address": "0x14000d796", + "size": 4, + "mnemonic": "lea", + "operands": "r11, [rcx + r10]" + }, + { + "address": "0x14000d79a", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r9 + r11*8]" + }, + { + "address": "0x14000d79e", + "size": 2, + "mnemonic": "cmp", + "operands": "edx, dword ptr [rax]" + }, + { + "address": "0x14000d7a0", + "size": 2, + "mnemonic": "je", + "operands": "0x14000d7d9" + } + ], + "successors": [ + "0x14000d7d9", + "0x14000d7a2" + ] + }, + { + "address": "0x14000d7cf", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d7cf", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r9 + r10*8]" + }, + { + "address": "0x14000d7d3", + "size": 2, + "mnemonic": "cmp", + "operands": "edx, dword ptr [rax]" + }, + { + "address": "0x14000d7d5", + "size": 4, + "mnemonic": "cmovne", + "operands": "rax, rsi" + }, + { + "address": "0x14000d7d9", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000d7dc", + "size": 2, + "mnemonic": "je", + "operands": "0x14000d7bb" + } + ], + "successors": [ + "0x14000d7bb", + "0x14000d7de" + ] + }, + { + "address": "0x14000d7d9", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d7d9", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000d7dc", + "size": 2, + "mnemonic": "je", + "operands": "0x14000d7bb" + } + ], + "successors": [ + "0x14000d7bb", + "0x14000d7de" + ] + }, + { + "address": "0x14000d7a2", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d7a2", + "size": 2, + "mnemonic": "jb", + "operands": "0x14000d7ab" + } + ], + "successors": [ + "0x14000d7ab", + "0x14000d7a4" + ] + }, + { + "address": "0x14000d7de", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d7de", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rax + 4]" + }, + { + "address": "0x14000d7e1", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000d7f7" + } + ], + "successors": [ + "0x14000d7f7" + ] + }, + { + "address": "0x14000d7ab", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d7ab", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r11 - 1]" + }, + { + "address": "0x14000d7af", + "size": 4, + "mnemonic": "cmovae", + "operands": "rax, rdi" + }, + { + "address": "0x14000d7b3", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rax" + }, + { + "address": "0x14000d7b6", + "size": 3, + "mnemonic": "cmp", + "operands": "r10, rax" + }, + { + "address": "0x14000d7b9", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14000d783" + }, + { + "address": "0x14000d7bb", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rdx - 0x13]" + }, + { + "address": "0x14000d7be", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, 0x11" + }, + { + "address": "0x14000d7c1", + "size": 2, + "mnemonic": "ja", + "operands": "0x14000d7e3" + } + ], + "successors": [ + "0x14000d7e3", + "0x14000d7c3" + ] + }, + { + "address": "0x14000d7a4", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d7a4", + "size": 4, + "mnemonic": "lea", + "operands": "r10, [r11 + 1]" + }, + { + "address": "0x14000d7a8", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r8" + }, + { + "address": "0x14000d7ab", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r11 - 1]" + }, + { + "address": "0x14000d7af", + "size": 4, + "mnemonic": "cmovae", + "operands": "rax, rdi" + }, + { + "address": "0x14000d7b3", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rax" + }, + { + "address": "0x14000d7b6", + "size": 3, + "mnemonic": "cmp", + "operands": "r10, rax" + }, + { + "address": "0x14000d7b9", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14000d783" + }, + { + "address": "0x14000d7bb", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rdx - 0x13]" + }, + { + "address": "0x14000d7be", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, 0x11" + }, + { + "address": "0x14000d7c1", + "size": 2, + "mnemonic": "ja", + "operands": "0x14000d7e3" + } + ], + "successors": [ + "0x14000d7e3", + "0x14000d7c3" + ] + } + ] + }, + { + "address": "0x140010b90", + "name": "", + "blocks": [ + { + "address": "0x140010b90", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010b90", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x140010b94", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rcx" + }, + { + "address": "0x140010b97", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140010b9a", + "size": 2, + "mnemonic": "je", + "operands": "0x140010ba9" + } + ], + "successors": [ + "0x140010ba9", + "0x140010b9c" + ] + }, + { + "address": "0x140010ba9", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140010ba9", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x140010bae", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0x16" + }, + { + "address": "0x140010bb4", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afb4" + }, + { + "address": "0x140010bb9", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x16" + }, + { + "address": "0x140010bbe", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x140010bc2", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140010b9c", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010b9c", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x140010b9f", + "size": 2, + "mnemonic": "je", + "operands": "0x140010ba9" + } + ], + "successors": [ + "0x140010ba9", + "0x140010ba1" + ] + }, + { + "address": "0x140010ba1", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140010ba1", + "size": 3, + "mnemonic": "test", + "operands": "r8, r8" + }, + { + "address": "0x140010ba4", + "size": 2, + "mnemonic": "jne", + "operands": "0x140010bc3" + }, + { + "address": "0x140010ba6", + "size": 3, + "mnemonic": "mov", + "operands": "byte ptr [rcx], r8b" + }, + { + "address": "0x140010ba9", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x140010bae", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0x16" + }, + { + "address": "0x140010bb4", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afb4" + }, + { + "address": "0x140010bb9", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x16" + }, + { + "address": "0x140010bbe", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x140010bc2", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000ace8", + "name": "", + "blocks": [ + { + "address": "0x14000ace8", + "size": 15, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ace8", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbx" + }, + { + "address": "0x14000aced", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x14000acf2", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000acf3", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000acf4", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000acf6", + "size": 8, + "mnemonic": "lea", + "operands": "rbp, [rsp - 0x4f0]" + }, + { + "address": "0x14000acfe", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x5f0" + }, + { + "address": "0x14000ad05", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x26334]" + }, + { + "address": "0x14000ad0c", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x14000ad0f", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rbp + 0x4e0], rax" + }, + { + "address": "0x14000ad16", + "size": 3, + "mnemonic": "mov", + "operands": "edi, r8d" + }, + { + "address": "0x14000ad19", + "size": 2, + "mnemonic": "mov", + "operands": "esi, edx" + }, + { + "address": "0x14000ad1b", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, ecx" + }, + { + "address": "0x14000ad1d", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, -1" + }, + { + "address": "0x14000ad20", + "size": 2, + "mnemonic": "je", + "operands": "0x14000ad27" + } + ], + "successors": [ + "0x14000ad27", + "0x14000ad22" + ] + } + ] + }, + { + "address": "0x14000ca90", + "name": "", + "blocks": [ + { + "address": "0x14000ca90", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ca90", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000ca94", + "size": 5, + "mnemonic": "call", + "operands": "0x140012358" + }, + { + "address": "0x14000ca99", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x26400]" + }, + { + "address": "0x14000caa0", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000caa4", + "size": 7, + "mnemonic": "jmp", + "operands": "qword ptr [rip + 0x13565]" + } + ], + "successors": [ + "0x140020010" + ] + } + ] + }, + { + "address": "0x140005134", + "name": "", + "blocks": [ + { + "address": "0x140005134", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005134", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140005136", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000513a", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14000513d", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000514e" + } + ], + "successors": [ + "0x14000514e" + ] + }, + { + "address": "0x14000514e", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000514e", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cac0" + }, + { + "address": "0x140005153", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140005156", + "size": 2, + "mnemonic": "je", + "operands": "0x14000513f" + } + ], + "successors": [ + "0x14000513f", + "0x140005158" + ] + }, + { + "address": "0x14000513f", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000513f", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140005142", + "size": 5, + "mnemonic": "call", + "operands": "0x14000deb0" + }, + { + "address": "0x140005147", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140005149", + "size": 2, + "mnemonic": "je", + "operands": "0x14000515e" + } + ], + "successors": [ + "0x14000515e", + "0x14000514b" + ] + }, + { + "address": "0x140005158", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140005158", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000515c", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000515d", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000515e", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000515e", + "size": 4, + "mnemonic": "cmp", + "operands": "rbx, -1" + }, + { + "address": "0x140005162", + "size": 2, + "mnemonic": "je", + "operands": "0x14000516a" + } + ], + "successors": [ + "0x14000516a", + "0x140005164" + ] + }, + { + "address": "0x14000514b", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000514b", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x14000514e", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cac0" + }, + { + "address": "0x140005153", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140005156", + "size": 2, + "mnemonic": "je", + "operands": "0x14000513f" + } + ], + "successors": [ + "0x14000513f", + "0x140005158" + ] + }, + { + "address": "0x14000516a", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000516a", + "size": 5, + "mnemonic": "call", + "operands": "0x140001dd0" + }, + { + "address": "0x14000516f", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140005164", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140005164", + "size": 5, + "mnemonic": "call", + "operands": "0x14000238c" + }, + { + "address": "0x140005169", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140002bb8", + "name": "", + "blocks": [ + { + "address": "0x140002bb8", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140002bb8", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140002bba", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140002bbe", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140002bc1", + "size": 5, + "mnemonic": "call", + "operands": "0x1400047dc" + }, + { + "address": "0x140002bc6", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x58]" + }, + { + "address": "0x140002bca", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140002bcd", + "size": 2, + "mnemonic": "je", + "operands": "0x140002bd4" + } + ], + "successors": [ + "0x140002bd4", + "0x140002bcf" + ] + }, + { + "address": "0x140002bd4", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140002bd4", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x58], 0" + }, + { + "address": "0x140002bdc", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x48]" + }, + { + "address": "0x140002be0", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140002be3", + "size": 2, + "mnemonic": "je", + "operands": "0x140002bea" + } + ], + "successors": [ + "0x140002bea", + "0x140002be5" + ] + }, + { + "address": "0x140002bcf", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140002bcf", + "size": 5, + "mnemonic": "call", + "operands": "0x14000c9d0" + }, + { + "address": "0x140002bd4", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x58], 0" + }, + { + "address": "0x140002bdc", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x48]" + }, + { + "address": "0x140002be0", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140002be3", + "size": 2, + "mnemonic": "je", + "operands": "0x140002bea" + } + ], + "successors": [ + "0x140002bea", + "0x140002be5" + ] + }, + { + "address": "0x140002bea", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140002bea", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x48], 0" + }, + { + "address": "0x140002bf2", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x38]" + }, + { + "address": "0x140002bf6", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140002bf9", + "size": 2, + "mnemonic": "je", + "operands": "0x140002c00" + } + ], + "successors": [ + "0x140002c00", + "0x140002bfb" + ] + }, + { + "address": "0x140002be5", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140002be5", + "size": 5, + "mnemonic": "call", + "operands": "0x14000c9d0" + }, + { + "address": "0x140002bea", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x48], 0" + }, + { + "address": "0x140002bf2", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x38]" + }, + { + "address": "0x140002bf6", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140002bf9", + "size": 2, + "mnemonic": "je", + "operands": "0x140002c00" + } + ], + "successors": [ + "0x140002c00", + "0x140002bfb" + ] + }, + { + "address": "0x140002c00", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140002c00", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x38], 0" + }, + { + "address": "0x140002c08", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x28]" + }, + { + "address": "0x140002c0c", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140002c0f", + "size": 2, + "mnemonic": "je", + "operands": "0x140002c16" + } + ], + "successors": [ + "0x140002c16", + "0x140002c11" + ] + }, + { + "address": "0x140002bfb", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140002bfb", + "size": 5, + "mnemonic": "call", + "operands": "0x14000c9d0" + }, + { + "address": "0x140002c00", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x38], 0" + }, + { + "address": "0x140002c08", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x28]" + }, + { + "address": "0x140002c0c", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140002c0f", + "size": 2, + "mnemonic": "je", + "operands": "0x140002c16" + } + ], + "successors": [ + "0x140002c16", + "0x140002c11" + ] + }, + { + "address": "0x140002c16", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140002c16", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x28], 0" + }, + { + "address": "0x140002c1e", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x18]" + }, + { + "address": "0x140002c22", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140002c25", + "size": 2, + "mnemonic": "je", + "operands": "0x140002c2c" + } + ], + "successors": [ + "0x140002c2c", + "0x140002c27" + ] + }, + { + "address": "0x140002c11", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140002c11", + "size": 5, + "mnemonic": "call", + "operands": "0x14000c9d0" + }, + { + "address": "0x140002c16", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x28], 0" + }, + { + "address": "0x140002c1e", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x18]" + }, + { + "address": "0x140002c22", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140002c25", + "size": 2, + "mnemonic": "je", + "operands": "0x140002c2c" + } + ], + "successors": [ + "0x140002c2c", + "0x140002c27" + ] + }, + { + "address": "0x140002c2c", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140002c2c", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x18], 0" + }, + { + "address": "0x140002c34", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 8]" + }, + { + "address": "0x140002c38", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140002c3b", + "size": 2, + "mnemonic": "je", + "operands": "0x140002c42" + } + ], + "successors": [ + "0x140002c42", + "0x140002c3d" + ] + }, + { + "address": "0x140002c27", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140002c27", + "size": 5, + "mnemonic": "call", + "operands": "0x14000c9d0" + }, + { + "address": "0x140002c2c", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x18], 0" + }, + { + "address": "0x140002c34", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 8]" + }, + { + "address": "0x140002c38", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140002c3b", + "size": 2, + "mnemonic": "je", + "operands": "0x140002c42" + } + ], + "successors": [ + "0x140002c42", + "0x140002c3d" + ] + }, + { + "address": "0x140002c42", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140002c42", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], 0" + }, + { + "address": "0x140002c4a", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140002c4d", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140002c51", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140002c52", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140004504" + } + ], + "successors": [ + "0x140004504" + ] + }, + { + "address": "0x140002c3d", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140002c3d", + "size": 5, + "mnemonic": "call", + "operands": "0x14000c9d0" + }, + { + "address": "0x140002c42", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], 0" + }, + { + "address": "0x140002c4a", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140002c4d", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140002c51", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140002c52", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140004504" + } + ], + "successors": [ + "0x140004504" + ] + } + ] + }, + { + "address": "0x1400029cc", + "name": "", + "blocks": [ + { + "address": "0x1400029cc", + "size": 24, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400029cc", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbx" + }, + { + "address": "0x1400029d1", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rcx" + }, + { + "address": "0x1400029d6", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x1400029d7", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400029db", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x1400029de", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x1400029e1", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x1400029e3", + "size": 5, + "mnemonic": "call", + "operands": "0x14000448c" + }, + { + "address": "0x1400029e8", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x1400029e9", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x1400029eb", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], rax" + }, + { + "address": "0x1400029ef", + "size": 3, + "mnemonic": "mov", + "operands": "byte ptr [rbx + 0x10], al" + }, + { + "address": "0x1400029f2", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x18], rax" + }, + { + "address": "0x1400029f6", + "size": 3, + "mnemonic": "mov", + "operands": "byte ptr [rbx + 0x20], al" + }, + { + "address": "0x1400029f9", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x28], rax" + }, + { + "address": "0x1400029fd", + "size": 4, + "mnemonic": "mov", + "operands": "word ptr [rbx + 0x30], ax" + }, + { + "address": "0x140002a01", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x38], rax" + }, + { + "address": "0x140002a05", + "size": 4, + "mnemonic": "mov", + "operands": "word ptr [rbx + 0x40], ax" + }, + { + "address": "0x140002a09", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x48], rax" + }, + { + "address": "0x140002a0d", + "size": 3, + "mnemonic": "mov", + "operands": "byte ptr [rbx + 0x50], al" + }, + { + "address": "0x140002a10", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x58], rax" + }, + { + "address": "0x140002a14", + "size": 3, + "mnemonic": "mov", + "operands": "byte ptr [rbx + 0x60], al" + }, + { + "address": "0x140002a17", + "size": 3, + "mnemonic": "test", + "operands": "rdi, rdi" + }, + { + "address": "0x140002a1a", + "size": 2, + "mnemonic": "je", + "operands": "0x140002a36" + } + ], + "successors": [ + "0x140002a36", + "0x140002a1c" + ] + }, + { + "address": "0x140002a36", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140002a36", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x1ea33]" + }, + { + "address": "0x140002a3d", + "size": 5, + "mnemonic": "call", + "operands": "0x1400023d0" + }, + { + "address": "0x140002a42", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140002a1c", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140002a1c", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rdi" + }, + { + "address": "0x140002a1f", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140002a22", + "size": 5, + "mnemonic": "call", + "operands": "0x140004770" + }, + { + "address": "0x140002a27", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140002a28", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140002a2b", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x38]" + }, + { + "address": "0x140002a30", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140002a34", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140002a35", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140002a80", + "name": "", + "blocks": [ + { + "address": "0x140002a80", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140002a80", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1e9b9]" + }, + { + "address": "0x140002a87", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 0x10], 0" + }, + { + "address": "0x140002a8f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 8], rax" + }, + { + "address": "0x140002a93", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1e996]" + }, + { + "address": "0x140002a9a", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rcx], rax" + }, + { + "address": "0x140002a9d", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rcx" + }, + { + "address": "0x140002aa0", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000238c", + "name": "", + "blocks": [ + { + "address": "0x14000238c", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000238c", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x48" + }, + { + "address": "0x140002390", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x20]" + }, + { + "address": "0x140002395", + "size": 5, + "mnemonic": "call", + "operands": "0x140002260" + }, + { + "address": "0x14000239a", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x2da6f]" + }, + { + "address": "0x1400023a1", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x20]" + }, + { + "address": "0x1400023a6", + "size": 5, + "mnemonic": "call", + "operands": "0x140006198" + }, + { + "address": "0x1400023ab", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140004910", + "name": "", + "blocks": [ + { + "address": "0x140004910", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004910", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140004915", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140004916", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000491a", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14000491d", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cf88" + }, + { + "address": "0x140004922", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 2" + }, + { + "address": "0x140004927", + "size": 2, + "mnemonic": "mov", + "operands": "dword ptr [rbx], eax" + }, + { + "address": "0x140004929", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0x100" + }, + { + "address": "0x14000492e", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d630" + }, + { + "address": "0x140004933", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], rax" + }, + { + "address": "0x140004937", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rax" + }, + { + "address": "0x14000493a", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000493d", + "size": 2, + "mnemonic": "je", + "operands": "0x14000499f" + } + ], + "successors": [ + "0x14000499f", + "0x14000493f" + ] + }, + { + "address": "0x14000499f", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000499f", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cdf4" + }, + { + "address": "0x1400049a4", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], rax" + }, + { + "address": "0x1400049a8", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 0x10], 0" + }, + { + "address": "0x1400049af", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cfb8" + }, + { + "address": "0x1400049b4", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax + 8]" + }, + { + "address": "0x1400049b8", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x18], rcx" + }, + { + "address": "0x1400049bc", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x1400049bf", + "size": 2, + "mnemonic": "je", + "operands": "0x1400049ca" + } + ], + "successors": [ + "0x1400049ca", + "0x1400049c1" + ] + }, + { + "address": "0x14000493f", + "size": 25, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000493f", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cdf4" + }, + { + "address": "0x140004944", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 4" + }, + { + "address": "0x140004949", + "size": 3, + "mnemonic": "lea", + "operands": "edx, [rcx + 0x7c]" + }, + { + "address": "0x14000494c", + "size": 3, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rax]" + }, + { + "address": "0x14000494f", + "size": 3, + "mnemonic": "movups", + "operands": "xmmword ptr [rdi], xmm0" + }, + { + "address": "0x140004952", + "size": 4, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rax + 0x10]" + }, + { + "address": "0x140004956", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rdi + 0x10], xmm1" + }, + { + "address": "0x14000495a", + "size": 4, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rax + 0x20]" + }, + { + "address": "0x14000495e", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rdi + 0x20], xmm0" + }, + { + "address": "0x140004962", + "size": 4, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rax + 0x30]" + }, + { + "address": "0x140004966", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rdi + 0x30], xmm1" + }, + { + "address": "0x14000496a", + "size": 4, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rax + 0x40]" + }, + { + "address": "0x14000496e", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rdi + 0x40], xmm0" + }, + { + "address": "0x140004972", + "size": 4, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rax + 0x50]" + }, + { + "address": "0x140004976", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rdi + 0x50], xmm1" + }, + { + "address": "0x14000497a", + "size": 4, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rax + 0x60]" + }, + { + "address": "0x14000497e", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rdi + 0x60], xmm0" + }, + { + "address": "0x140004982", + "size": 3, + "mnemonic": "add", + "operands": "rdi, rdx" + }, + { + "address": "0x140004985", + "size": 4, + "mnemonic": "movups", + "operands": "xmm1, xmmword ptr [rax + 0x70]" + }, + { + "address": "0x140004989", + "size": 3, + "mnemonic": "add", + "operands": "rax, rdx" + }, + { + "address": "0x14000498c", + "size": 4, + "mnemonic": "movups", + "operands": "xmmword ptr [rdi - 0x10], xmm1" + }, + { + "address": "0x140004990", + "size": 4, + "mnemonic": "sub", + "operands": "rcx, 1" + }, + { + "address": "0x140004994", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000494c" + }, + { + "address": "0x140004996", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rbx + 0x10], 1" + }, + { + "address": "0x14000499d", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400049af" + } + ], + "successors": [ + "0x1400049af" + ] + }, + { + "address": "0x1400049ca", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400049ca", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x1400049cd", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x1400049d2", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400049d6", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400049d7", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400049c1", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400049c1", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d640" + }, + { + "address": "0x1400049c6", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x18], rax" + }, + { + "address": "0x1400049ca", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x1400049cd", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x1400049d2", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400049d6", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400049d7", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400049af", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400049af", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cfb8" + }, + { + "address": "0x1400049b4", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax + 8]" + }, + { + "address": "0x1400049b8", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 0x18], rcx" + }, + { + "address": "0x1400049bc", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x1400049bf", + "size": 2, + "mnemonic": "je", + "operands": "0x1400049ca" + } + ], + "successors": [ + "0x1400049ca", + "0x1400049c1" + ] + } + ] + }, + { + "address": "0x140015b2c", + "name": "", + "blocks": [ + { + "address": "0x140015b2c", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015b2c", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140015b2e", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140015b32", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x1d6ff]" + }, + { + "address": "0x140015b39", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdx" + }, + { + "address": "0x140015b3c", + "size": 3, + "mnemonic": "cmp", + "operands": "qword ptr [rdx], rax" + }, + { + "address": "0x140015b3f", + "size": 2, + "mnemonic": "je", + "operands": "0x140015b57" + } + ], + "successors": [ + "0x140015b57", + "0x140015b41" + ] + }, + { + "address": "0x140015b57", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140015b57", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140015b5b", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140015b5c", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140015b41", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140015b41", + "size": 6, + "mnemonic": "mov", + "operands": "eax, dword ptr [rcx + 0x3a8]" + }, + { + "address": "0x140015b47", + "size": 6, + "mnemonic": "test", + "operands": "dword ptr [rip + 0x1ba43], eax" + }, + { + "address": "0x140015b4d", + "size": 2, + "mnemonic": "jne", + "operands": "0x140015b57" + }, + { + "address": "0x140015b4f", + "size": 5, + "mnemonic": "call", + "operands": "0x14001a8ec" + }, + { + "address": "0x140015b54", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rbx], rax" + }, + { + "address": "0x140015b57", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140015b5b", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140015b5c", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400105b0", + "name": "", + "blocks": [ + { + "address": "0x1400105b0", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400105b0", + "size": 6, + "mnemonic": "mov", + "operands": "eax, dword ptr [rip + 0x22c3e]" + }, + { + "address": "0x1400105b6", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x1400105b7", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000deb0", + "name": "", + "blocks": [ + { + "address": "0x14000deb0", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000deb0", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000deb5", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000deb6", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000deba", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x14000debd", + "size": 5, + "mnemonic": "call", + "operands": "0x14000df00" + }, + { + "address": "0x14000dec2", + "size": 2, + "mnemonic": "xor", + "operands": "ebx, ebx" + }, + { + "address": "0x14000dec4", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000dec7", + "size": 2, + "mnemonic": "je", + "operands": "0x14000ded8" + } + ], + "successors": [ + "0x14000ded8", + "0x14000dec9" + ] + }, + { + "address": "0x14000ded8", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000ded8", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000dedd", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000dee1", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000dee2", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000dec9", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000dec9", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x14000decc", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3a0" + }, + { + "address": "0x14000ded1", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000ded3", + "size": 3, + "mnemonic": "setne", + "operands": "bl" + }, + { + "address": "0x14000ded6", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ebx" + }, + { + "address": "0x14000ded8", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000dedd", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000dee1", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000dee2", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400075d8", + "name": "", + "blocks": [ + { + "address": "0x1400075d8", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400075d8", + "size": 3, + "mnemonic": "mov", + "operands": "r8, qword ptr [rdx]" + }, + { + "address": "0x1400075db", + "size": 5, + "mnemonic": "jmp", + "operands": "0x1400075e8" + } + ], + "successors": [ + "0x1400075e8" + ] + }, + { + "address": "0x1400075e8", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400075e8", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x1400075ea", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400075ee", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r8" + }, + { + "address": "0x1400075f1", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x1400075f4", + "size": 2, + "mnemonic": "je", + "operands": "0x140007648" + } + ], + "successors": [ + "0x140007648", + "0x1400075f6" + ] + }, + { + "address": "0x140007648", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007648", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x14000764d", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400075f6", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400075f6", + "size": 4, + "mnemonic": "movsxd", + "operands": "r11, dword ptr [rcx + 0x18]" + }, + { + "address": "0x1400075fa", + "size": 4, + "mnemonic": "mov", + "operands": "r10, qword ptr [rdx + 8]" + }, + { + "address": "0x1400075fe", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r10 + r11]" + }, + { + "address": "0x140007602", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140007605", + "size": 2, + "mnemonic": "je", + "operands": "0x140007648" + } + ], + "successors": [ + "0x140007648", + "0x140007607" + ] + }, + { + "address": "0x140007607", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007607", + "size": 4, + "mnemonic": "mov", + "operands": "r8d, dword ptr [rcx + 0x14]" + }, + { + "address": "0x14000760b", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x14000760e", + "size": 3, + "mnemonic": "test", + "operands": "r8d, r8d" + }, + { + "address": "0x140007611", + "size": 2, + "mnemonic": "je", + "operands": "0x140007643" + } + ], + "successors": [ + "0x140007643", + "0x140007613" + ] + }, + { + "address": "0x140007643", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007643", + "size": 3, + "mnemonic": "or", + "operands": "eax, 0xffffffff" + }, + { + "address": "0x140007646", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000763d" + } + ], + "successors": [ + "0x14000763d" + ] + }, + { + "address": "0x140007613", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007613", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [r11 + r9*8]" + }, + { + "address": "0x140007617", + "size": 4, + "mnemonic": "movsxd", + "operands": "rdx, dword ptr [rcx + r10]" + }, + { + "address": "0x14000761b", + "size": 3, + "mnemonic": "add", + "operands": "rdx, r10" + }, + { + "address": "0x14000761e", + "size": 3, + "mnemonic": "cmp", + "operands": "rbx, rdx" + }, + { + "address": "0x140007621", + "size": 2, + "mnemonic": "jb", + "operands": "0x14000762b" + } + ], + "successors": [ + "0x14000762b", + "0x140007623" + ] + }, + { + "address": "0x14000763d", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000763d", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140007641", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140007642", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000762b", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000762b", + "size": 3, + "mnemonic": "test", + "operands": "r9d, r9d" + }, + { + "address": "0x14000762e", + "size": 2, + "mnemonic": "je", + "operands": "0x140007643" + } + ], + "successors": [ + "0x140007643", + "0x140007630" + ] + }, + { + "address": "0x140007623", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007623", + "size": 3, + "mnemonic": "inc", + "operands": "r9d" + }, + { + "address": "0x140007626", + "size": 3, + "mnemonic": "cmp", + "operands": "r9d, r8d" + }, + { + "address": "0x140007629", + "size": 2, + "mnemonic": "jb", + "operands": "0x140007613" + } + ], + "successors": [ + "0x140007613", + "0x14000762b" + ] + }, + { + "address": "0x140007630", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140007630", + "size": 4, + "mnemonic": "lea", + "operands": "ecx, [r9 - 1]" + }, + { + "address": "0x140007634", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r10 + rcx*8]" + }, + { + "address": "0x140007638", + "size": 5, + "mnemonic": "mov", + "operands": "eax, dword ptr [rax + r11 + 4]" + }, + { + "address": "0x14000763d", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140007641", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140007642", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140007740", + "name": "", + "blocks": [ + { + "address": "0x140007740", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007740", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140007745", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rsi" + }, + { + "address": "0x14000774a", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rdi" + }, + { + "address": "0x14000774f", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140007751", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140007753", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140007755", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x140007759", + "size": 3, + "mnemonic": "mov", + "operands": "r14, r9" + }, + { + "address": "0x14000775c", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r8" + }, + { + "address": "0x14000775f", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rdx" + }, + { + "address": "0x140007762", + "size": 3, + "mnemonic": "mov", + "operands": "r13, rcx" + }, + { + "address": "0x140007765", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x140007767", + "size": 4, + "mnemonic": "movsxd", + "operands": "r15, dword ptr [r8 + 4]" + }, + { + "address": "0x14000776b", + "size": 3, + "mnemonic": "test", + "operands": "r15d, r15d" + }, + { + "address": "0x14000776e", + "size": 2, + "mnemonic": "je", + "operands": "0x14000777b" + } + ], + "successors": [ + "0x14000777b", + "0x140007770" + ] + }, + { + "address": "0x14000777b", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000777b", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rdi" + }, + { + "address": "0x14000777e", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x140007781", + "size": 6, + "mnemonic": "je", + "operands": "0x1400078f6" + } + ], + "successors": [ + "0x1400078f6", + "0x140007787" + ] + }, + { + "address": "0x140007770", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007770", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140007775", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [r15 + rax]" + }, + { + "address": "0x140007779", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000777e" + } + ], + "successors": [ + "0x14000777e" + ] + }, + { + "address": "0x1400078f6", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400078f6", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x1400078f8", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x50]" + }, + { + "address": "0x1400078fd", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x58]" + }, + { + "address": "0x140007902", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x60]" + }, + { + "address": "0x140007907", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000790b", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000790d", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000790f", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140007911", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140007787", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007787", + "size": 4, + "mnemonic": "movsxd", + "operands": "r15, dword ptr [rbx + 4]" + }, + { + "address": "0x14000778b", + "size": 3, + "mnemonic": "test", + "operands": "r15d, r15d" + }, + { + "address": "0x14000778e", + "size": 2, + "mnemonic": "je", + "operands": "0x14000779b" + } + ], + "successors": [ + "0x14000779b", + "0x140007790" + ] + }, + { + "address": "0x14000777e", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000777e", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x140007781", + "size": 6, + "mnemonic": "je", + "operands": "0x1400078f6" + } + ], + "successors": [ + "0x1400078f6", + "0x140007787" + ] + }, + { + "address": "0x14000779b", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000779b", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x14000779e", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rcx + 0x10], dil" + }, + { + "address": "0x1400077a2", + "size": 6, + "mnemonic": "je", + "operands": "0x1400078f6" + } + ], + "successors": [ + "0x1400078f6", + "0x1400077a8" + ] + }, + { + "address": "0x140007790", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007790", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140007795", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [r15 + rax]" + }, + { + "address": "0x140007799", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000779e" + } + ], + "successors": [ + "0x14000779e" + ] + }, + { + "address": "0x1400077a8", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400077a8", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rbx + 8], edi" + }, + { + "address": "0x1400077ab", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400077b5" + }, + { + "address": "0x1400077ad", + "size": 2, + "mnemonic": "cmp", + "operands": "dword ptr [rbx], edi" + }, + { + "address": "0x1400077af", + "size": 6, + "mnemonic": "jge", + "operands": "0x1400078f6" + }, + { + "address": "0x1400077b5", + "size": 2, + "mnemonic": "cmp", + "operands": "dword ptr [rbx], edi" + }, + { + "address": "0x1400077b7", + "size": 2, + "mnemonic": "jl", + "operands": "0x1400077c3" + } + ], + "successors": [ + "0x1400077c3", + "0x1400077b9" + ] + }, + { + "address": "0x14000779e", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000779e", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rcx + 0x10], dil" + }, + { + "address": "0x1400077a2", + "size": 6, + "mnemonic": "je", + "operands": "0x1400078f6" + } + ], + "successors": [ + "0x1400078f6", + "0x1400077a8" + ] + }, + { + "address": "0x1400077c3", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400077c3", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [rbx], 0x80" + }, + { + "address": "0x1400077c6", + "size": 2, + "mnemonic": "je", + "operands": "0x1400077fa" + } + ], + "successors": [ + "0x1400077fa", + "0x1400077c8" + ] + }, + { + "address": "0x1400077b9", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400077b9", + "size": 4, + "mnemonic": "movsxd", + "operands": "rax, dword ptr [rbx + 8]" + }, + { + "address": "0x1400077bd", + "size": 3, + "mnemonic": "add", + "operands": "rax, qword ptr [rsi]" + }, + { + "address": "0x1400077c0", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rax" + }, + { + "address": "0x1400077c3", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [rbx], 0x80" + }, + { + "address": "0x1400077c6", + "size": 2, + "mnemonic": "je", + "operands": "0x1400077fa" + } + ], + "successors": [ + "0x1400077fa", + "0x1400077c8" + ] + }, + { + "address": "0x1400077fa", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400077fa", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [rbx], 8" + }, + { + "address": "0x1400077fd", + "size": 2, + "mnemonic": "je", + "operands": "0x14000781a" + } + ], + "successors": [ + "0x14000781a", + "0x1400077ff" + ] + }, + { + "address": "0x1400077c8", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400077c8", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [r14], 0x10" + }, + { + "address": "0x1400077cc", + "size": 2, + "mnemonic": "je", + "operands": "0x1400077fa" + } + ], + "successors": [ + "0x1400077fa", + "0x1400077ce" + ] + }, + { + "address": "0x14000781a", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000781a", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [r14], 1" + }, + { + "address": "0x14000781e", + "size": 2, + "mnemonic": "je", + "operands": "0x14000786a" + } + ], + "successors": [ + "0x14000786a", + "0x140007820" + ] + }, + { + "address": "0x1400077ff", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400077ff", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r13 + 0x28]" + }, + { + "address": "0x140007803", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140007806", + "size": 6, + "mnemonic": "je", + "operands": "0x140007917" + } + ], + "successors": [ + "0x140007917", + "0x14000780c" + ] + }, + { + "address": "0x1400077ce", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400077ce", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x2b4fb]" + }, + { + "address": "0x1400077d5", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x1400077d8", + "size": 2, + "mnemonic": "je", + "operands": "0x1400077fa" + } + ], + "successors": [ + "0x1400077fa", + "0x1400077da" + ] + }, + { + "address": "0x14000786a", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000786a", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [r14 + 0x18]" + }, + { + "address": "0x14000786e", + "size": 2, + "mnemonic": "test", + "operands": "ebx, ebx" + }, + { + "address": "0x140007870", + "size": 2, + "mnemonic": "je", + "operands": "0x14000787d" + } + ], + "successors": [ + "0x14000787d", + "0x140007872" + ] + }, + { + "address": "0x140007820", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007820", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [r13 + 0x28]" + }, + { + "address": "0x140007824", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x140007827", + "size": 6, + "mnemonic": "je", + "operands": "0x14000791c" + } + ], + "successors": [ + "0x14000791c", + "0x14000782d" + ] + }, + { + "address": "0x140007917", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007917", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x14000791c", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007921", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007926", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x14000792b", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14000792c", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007931", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140007932", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000780c", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000780c", + "size": 3, + "mnemonic": "test", + "operands": "rsi, rsi" + }, + { + "address": "0x14000780f", + "size": 6, + "mnemonic": "je", + "operands": "0x140007917" + } + ], + "successors": [ + "0x140007917", + "0x140007815" + ] + }, + { + "address": "0x1400077da", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400077da", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x18ae0]" + }, + { + "address": "0x1400077e0", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x1400077e3", + "size": 6, + "mnemonic": "je", + "operands": "0x140007912" + } + ], + "successors": [ + "0x140007912", + "0x1400077e9" + ] + }, + { + "address": "0x14000787d", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000787d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140007880", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140007883", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400078b9" + }, + { + "address": "0x140007885", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [r13 + 0x28], rdi" + }, + { + "address": "0x140007889", + "size": 6, + "mnemonic": "je", + "operands": "0x140007921" + } + ], + "successors": [ + "0x140007921", + "0x14000788f" + ] + }, + { + "address": "0x140007872", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007872", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x140007877", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbx + rax]" + }, + { + "address": "0x14000787b", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140007880" + } + ], + "successors": [ + "0x140007880" + ] + }, + { + "address": "0x14000791c", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000791c", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007921", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007926", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x14000792b", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14000792c", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007931", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140007932", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000782d", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000782d", + "size": 3, + "mnemonic": "test", + "operands": "rsi, rsi" + }, + { + "address": "0x140007830", + "size": 6, + "mnemonic": "je", + "operands": "0x14000791c" + } + ], + "successors": [ + "0x14000791c", + "0x140007836" + ] + }, + { + "address": "0x140007815", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007815", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rsi], rcx" + }, + { + "address": "0x140007818", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140007859" + } + ], + "successors": [ + "0x140007859" + ] + }, + { + "address": "0x140007912", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007912", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007917", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x14000791c", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007921", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007926", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x14000792b", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14000792c", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007931", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140007932", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400077e9", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400077e9", + "size": 3, + "mnemonic": "test", + "operands": "rsi, rsi" + }, + { + "address": "0x1400077ec", + "size": 6, + "mnemonic": "je", + "operands": "0x140007912" + } + ], + "successors": [ + "0x140007912", + "0x1400077f2" + ] + }, + { + "address": "0x140007921", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007921", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007926", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x14000792b", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14000792c", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007931", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140007932", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000788f", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000788f", + "size": 3, + "mnemonic": "test", + "operands": "rsi, rsi" + }, + { + "address": "0x140007892", + "size": 6, + "mnemonic": "je", + "operands": "0x140007921" + } + ], + "successors": [ + "0x140007921", + "0x140007898" + ] + }, + { + "address": "0x140007880", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007880", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140007883", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400078b9" + }, + { + "address": "0x140007885", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [r13 + 0x28], rdi" + }, + { + "address": "0x140007889", + "size": 6, + "mnemonic": "je", + "operands": "0x140007921" + } + ], + "successors": [ + "0x140007921", + "0x14000788f" + ] + }, + { + "address": "0x140007836", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007836", + "size": 4, + "mnemonic": "movsxd", + "operands": "r8, dword ptr [r14 + 0x14]" + }, + { + "address": "0x14000783a", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x14000783d", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3e0" + }, + { + "address": "0x140007842", + "size": 5, + "mnemonic": "cmp", + "operands": "dword ptr [r14 + 0x14], 8" + }, + { + "address": "0x140007847", + "size": 6, + "mnemonic": "jne", + "operands": "0x1400078f2" + }, + { + "address": "0x14000784d", + "size": 3, + "mnemonic": "cmp", + "operands": "qword ptr [rsi], rdi" + }, + { + "address": "0x140007850", + "size": 6, + "mnemonic": "je", + "operands": "0x1400078f2" + } + ], + "successors": [ + "0x1400078f2", + "0x140007856" + ] + }, + { + "address": "0x140007859", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007859", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [r14 + 8]" + }, + { + "address": "0x14000785d", + "size": 5, + "mnemonic": "call", + "operands": "0x140007040" + }, + { + "address": "0x140007862", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rsi], rax" + }, + { + "address": "0x140007865", + "size": 5, + "mnemonic": "jmp", + "operands": "0x1400078f2" + } + ], + "successors": [ + "0x1400078f2" + ] + }, + { + "address": "0x1400077f2", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400077f2", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rsi], rax" + }, + { + "address": "0x1400077f5", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x1400077f8", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140007859" + } + ], + "successors": [ + "0x140007859" + ] + }, + { + "address": "0x140007898", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007898", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [r14 + 0x14]" + }, + { + "address": "0x14000789c", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [r14 + 8]" + }, + { + "address": "0x1400078a0", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r13 + 0x28]" + }, + { + "address": "0x1400078a4", + "size": 5, + "mnemonic": "call", + "operands": "0x140007040" + }, + { + "address": "0x1400078a9", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rax" + }, + { + "address": "0x1400078ac", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rbx" + }, + { + "address": "0x1400078af", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x1400078b2", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3e0" + }, + { + "address": "0x1400078b7", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400078f2" + } + ], + "successors": [ + "0x1400078f2" + ] + }, + { + "address": "0x1400078f2", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400078f2", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x1400078f4", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400078f8" + } + ], + "successors": [ + "0x1400078f8" + ] + }, + { + "address": "0x140007856", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007856", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsi]" + }, + { + "address": "0x140007859", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [r14 + 8]" + }, + { + "address": "0x14000785d", + "size": 5, + "mnemonic": "call", + "operands": "0x140007040" + }, + { + "address": "0x140007862", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rsi], rax" + }, + { + "address": "0x140007865", + "size": 5, + "mnemonic": "jmp", + "operands": "0x1400078f2" + } + ], + "successors": [ + "0x1400078f2" + ] + }, + { + "address": "0x1400078f8", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400078f8", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x50]" + }, + { + "address": "0x1400078fd", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x58]" + }, + { + "address": "0x140007902", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x60]" + }, + { + "address": "0x140007907", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000790b", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000790d", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000790f", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140007911", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140007040", + "name": "", + "blocks": [ + { + "address": "0x140007040", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007040", + "size": 3, + "mnemonic": "movsxd", + "operands": "rax, dword ptr [rdx]" + }, + { + "address": "0x140007043", + "size": 3, + "mnemonic": "add", + "operands": "rax, rcx" + }, + { + "address": "0x140007046", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rdx + 4], 0" + }, + { + "address": "0x14000704a", + "size": 2, + "mnemonic": "jl", + "operands": "0x140007062" + } + ], + "successors": [ + "0x140007062", + "0x14000704c" + ] + }, + { + "address": "0x140007062", + "size": 1, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140007062", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000704c", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000704c", + "size": 4, + "mnemonic": "movsxd", + "operands": "r9, dword ptr [rdx + 4]" + }, + { + "address": "0x140007050", + "size": 4, + "mnemonic": "movsxd", + "operands": "rdx, dword ptr [rdx + 8]" + }, + { + "address": "0x140007054", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r9 + rcx]" + }, + { + "address": "0x140007058", + "size": 4, + "mnemonic": "movsxd", + "operands": "r8, dword ptr [rdx + rcx]" + }, + { + "address": "0x14000705c", + "size": 3, + "mnemonic": "add", + "operands": "r8, r9" + }, + { + "address": "0x14000705f", + "size": 3, + "mnemonic": "add", + "operands": "rax, r8" + }, + { + "address": "0x140007062", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000a504", + "name": "", + "blocks": [ + { + "address": "0x14000a504", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a504", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdx" + }, + { + "address": "0x14000a507", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r8" + }, + { + "address": "0x14000a50a", + "size": 3, + "mnemonic": "jmp", + "operands": "rax" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000a510", + "name": "", + "blocks": [ + { + "address": "0x14000a510", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a510", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r8" + }, + { + "address": "0x14000a513", + "size": 3, + "mnemonic": "mov", + "operands": "r10, rdx" + }, + { + "address": "0x14000a516", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rax" + }, + { + "address": "0x14000a519", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, r9d" + }, + { + "address": "0x14000a51c", + "size": 3, + "mnemonic": "jmp", + "operands": "r10" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140007934", + "name": "", + "blocks": [ + { + "address": "0x140007934", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007934", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140007939", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rsi" + }, + { + "address": "0x14000793e", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rdi" + }, + { + "address": "0x140007943", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140007945", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140007947", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140007949", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000794d", + "size": 3, + "mnemonic": "mov", + "operands": "r14, r9" + }, + { + "address": "0x140007950", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r8" + }, + { + "address": "0x140007953", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rdx" + }, + { + "address": "0x140007956", + "size": 3, + "mnemonic": "mov", + "operands": "r13, rcx" + }, + { + "address": "0x140007959", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x14000795b", + "size": 4, + "mnemonic": "movsxd", + "operands": "r15, dword ptr [r8 + 8]" + }, + { + "address": "0x14000795f", + "size": 3, + "mnemonic": "test", + "operands": "r15d, r15d" + }, + { + "address": "0x140007962", + "size": 2, + "mnemonic": "je", + "operands": "0x14000796f" + } + ], + "successors": [ + "0x14000796f", + "0x140007964" + ] + }, + { + "address": "0x14000796f", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000796f", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rdi" + }, + { + "address": "0x140007972", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x140007975", + "size": 6, + "mnemonic": "je", + "operands": "0x140007aed" + } + ], + "successors": [ + "0x140007aed", + "0x14000797b" + ] + }, + { + "address": "0x140007964", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007964", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140007969", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [r15 + rax]" + }, + { + "address": "0x14000796d", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140007972" + } + ], + "successors": [ + "0x140007972" + ] + }, + { + "address": "0x140007aed", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140007aed", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140007aef", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x50]" + }, + { + "address": "0x140007af4", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x58]" + }, + { + "address": "0x140007af9", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x60]" + }, + { + "address": "0x140007afe", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140007b02", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140007b04", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140007b06", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140007b08", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000797b", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000797b", + "size": 4, + "mnemonic": "movsxd", + "operands": "r15, dword ptr [rbx + 8]" + }, + { + "address": "0x14000797f", + "size": 3, + "mnemonic": "test", + "operands": "r15d, r15d" + }, + { + "address": "0x140007982", + "size": 2, + "mnemonic": "je", + "operands": "0x14000798f" + } + ], + "successors": [ + "0x14000798f", + "0x140007984" + ] + }, + { + "address": "0x140007972", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007972", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x140007975", + "size": 6, + "mnemonic": "je", + "operands": "0x140007aed" + } + ], + "successors": [ + "0x140007aed", + "0x14000797b" + ] + }, + { + "address": "0x14000798f", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000798f", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140007992", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rcx + 0x10], dil" + }, + { + "address": "0x140007996", + "size": 6, + "mnemonic": "je", + "operands": "0x140007aed" + } + ], + "successors": [ + "0x140007aed", + "0x14000799c" + ] + }, + { + "address": "0x140007984", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007984", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140007989", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [r15 + rax]" + }, + { + "address": "0x14000798d", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140007992" + } + ], + "successors": [ + "0x140007992" + ] + }, + { + "address": "0x14000799c", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000799c", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rbx + 0xc], edi" + }, + { + "address": "0x14000799f", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400079aa" + }, + { + "address": "0x1400079a1", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rbx + 4], edi" + }, + { + "address": "0x1400079a4", + "size": 6, + "mnemonic": "jge", + "operands": "0x140007aed" + }, + { + "address": "0x1400079aa", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rbx + 4], edi" + }, + { + "address": "0x1400079ad", + "size": 2, + "mnemonic": "jl", + "operands": "0x1400079b8" + } + ], + "successors": [ + "0x1400079b8", + "0x1400079af" + ] + }, + { + "address": "0x140007992", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007992", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rcx + 0x10], dil" + }, + { + "address": "0x140007996", + "size": 6, + "mnemonic": "je", + "operands": "0x140007aed" + } + ], + "successors": [ + "0x140007aed", + "0x14000799c" + ] + }, + { + "address": "0x1400079b8", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400079b8", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [rbx + 4], 0x80" + }, + { + "address": "0x1400079bc", + "size": 2, + "mnemonic": "je", + "operands": "0x1400079f0" + } + ], + "successors": [ + "0x1400079f0", + "0x1400079be" + ] + }, + { + "address": "0x1400079af", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400079af", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbx + 0xc]" + }, + { + "address": "0x1400079b2", + "size": 3, + "mnemonic": "add", + "operands": "rax, qword ptr [rsi]" + }, + { + "address": "0x1400079b5", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rax" + }, + { + "address": "0x1400079b8", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [rbx + 4], 0x80" + }, + { + "address": "0x1400079bc", + "size": 2, + "mnemonic": "je", + "operands": "0x1400079f0" + } + ], + "successors": [ + "0x1400079f0", + "0x1400079be" + ] + }, + { + "address": "0x1400079f0", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400079f0", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [rbx + 4], 8" + }, + { + "address": "0x1400079f4", + "size": 2, + "mnemonic": "je", + "operands": "0x140007a11" + } + ], + "successors": [ + "0x140007a11", + "0x1400079f6" + ] + }, + { + "address": "0x1400079be", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400079be", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [r14], 0x10" + }, + { + "address": "0x1400079c2", + "size": 2, + "mnemonic": "je", + "operands": "0x1400079f0" + } + ], + "successors": [ + "0x1400079f0", + "0x1400079c4" + ] + }, + { + "address": "0x140007a11", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007a11", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [r14], 1" + }, + { + "address": "0x140007a15", + "size": 2, + "mnemonic": "je", + "operands": "0x140007a61" + } + ], + "successors": [ + "0x140007a61", + "0x140007a17" + ] + }, + { + "address": "0x1400079f6", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400079f6", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r13 + 0x28]" + }, + { + "address": "0x1400079fa", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x1400079fd", + "size": 6, + "mnemonic": "je", + "operands": "0x140007b0e" + } + ], + "successors": [ + "0x140007b0e", + "0x140007a03" + ] + }, + { + "address": "0x1400079c4", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400079c4", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x2b305]" + }, + { + "address": "0x1400079cb", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x1400079ce", + "size": 2, + "mnemonic": "je", + "operands": "0x1400079f0" + } + ], + "successors": [ + "0x1400079f0", + "0x1400079d0" + ] + }, + { + "address": "0x140007a61", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007a61", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [r14 + 0x18]" + }, + { + "address": "0x140007a65", + "size": 2, + "mnemonic": "test", + "operands": "ebx, ebx" + }, + { + "address": "0x140007a67", + "size": 2, + "mnemonic": "je", + "operands": "0x140007a74" + } + ], + "successors": [ + "0x140007a74", + "0x140007a69" + ] + }, + { + "address": "0x140007a17", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007a17", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [r13 + 0x28]" + }, + { + "address": "0x140007a1b", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x140007a1e", + "size": 6, + "mnemonic": "je", + "operands": "0x140007b13" + } + ], + "successors": [ + "0x140007b13", + "0x140007a24" + ] + }, + { + "address": "0x140007b0e", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007b0e", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007b13", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007b18", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007b1d", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007b22", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140007b23", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007b28", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140007b29", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140007a03", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007a03", + "size": 3, + "mnemonic": "test", + "operands": "rsi, rsi" + }, + { + "address": "0x140007a06", + "size": 6, + "mnemonic": "je", + "operands": "0x140007b0e" + } + ], + "successors": [ + "0x140007b0e", + "0x140007a0c" + ] + }, + { + "address": "0x1400079d0", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400079d0", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x188ea]" + }, + { + "address": "0x1400079d6", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x1400079d9", + "size": 6, + "mnemonic": "je", + "operands": "0x140007b09" + } + ], + "successors": [ + "0x140007b09", + "0x1400079df" + ] + }, + { + "address": "0x140007a74", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007a74", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140007a77", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140007a7a", + "size": 2, + "mnemonic": "jne", + "operands": "0x140007ab0" + }, + { + "address": "0x140007a7c", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [r13 + 0x28], rdi" + }, + { + "address": "0x140007a80", + "size": 6, + "mnemonic": "je", + "operands": "0x140007b18" + } + ], + "successors": [ + "0x140007b18", + "0x140007a86" + ] + }, + { + "address": "0x140007a69", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007a69", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x140007a6e", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbx + rax]" + }, + { + "address": "0x140007a72", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140007a77" + } + ], + "successors": [ + "0x140007a77" + ] + }, + { + "address": "0x140007b13", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007b13", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007b18", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007b1d", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007b22", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140007b23", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007b28", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140007b29", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140007a24", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007a24", + "size": 3, + "mnemonic": "test", + "operands": "rsi, rsi" + }, + { + "address": "0x140007a27", + "size": 6, + "mnemonic": "je", + "operands": "0x140007b13" + } + ], + "successors": [ + "0x140007b13", + "0x140007a2d" + ] + }, + { + "address": "0x140007a0c", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007a0c", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rsi], rcx" + }, + { + "address": "0x140007a0f", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140007a50" + } + ], + "successors": [ + "0x140007a50" + ] + }, + { + "address": "0x140007b09", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007b09", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007b0e", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007b13", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007b18", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007b1d", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007b22", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140007b23", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007b28", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140007b29", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400079df", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400079df", + "size": 3, + "mnemonic": "test", + "operands": "rsi, rsi" + }, + { + "address": "0x1400079e2", + "size": 6, + "mnemonic": "je", + "operands": "0x140007b09" + } + ], + "successors": [ + "0x140007b09", + "0x1400079e8" + ] + }, + { + "address": "0x140007b18", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007b18", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007b1d", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007b22", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140007b23", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140007b28", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140007b29", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140007a86", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007a86", + "size": 3, + "mnemonic": "test", + "operands": "rsi, rsi" + }, + { + "address": "0x140007a89", + "size": 6, + "mnemonic": "je", + "operands": "0x140007b18" + } + ], + "successors": [ + "0x140007b18", + "0x140007a8f" + ] + }, + { + "address": "0x140007a77", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007a77", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140007a7a", + "size": 2, + "mnemonic": "jne", + "operands": "0x140007ab0" + }, + { + "address": "0x140007a7c", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [r13 + 0x28], rdi" + }, + { + "address": "0x140007a80", + "size": 6, + "mnemonic": "je", + "operands": "0x140007b18" + } + ], + "successors": [ + "0x140007b18", + "0x140007a86" + ] + }, + { + "address": "0x140007a2d", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007a2d", + "size": 4, + "mnemonic": "movsxd", + "operands": "r8, dword ptr [r14 + 0x14]" + }, + { + "address": "0x140007a31", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x140007a34", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3e0" + }, + { + "address": "0x140007a39", + "size": 5, + "mnemonic": "cmp", + "operands": "dword ptr [r14 + 0x14], 8" + }, + { + "address": "0x140007a3e", + "size": 6, + "mnemonic": "jne", + "operands": "0x140007ae9" + }, + { + "address": "0x140007a44", + "size": 3, + "mnemonic": "cmp", + "operands": "qword ptr [rsi], rdi" + }, + { + "address": "0x140007a47", + "size": 6, + "mnemonic": "je", + "operands": "0x140007ae9" + } + ], + "successors": [ + "0x140007ae9", + "0x140007a4d" + ] + }, + { + "address": "0x140007a50", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007a50", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [r14 + 8]" + }, + { + "address": "0x140007a54", + "size": 5, + "mnemonic": "call", + "operands": "0x140007040" + }, + { + "address": "0x140007a59", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rsi], rax" + }, + { + "address": "0x140007a5c", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140007ae9" + } + ], + "successors": [ + "0x140007ae9" + ] + }, + { + "address": "0x1400079e8", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400079e8", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rsi], rax" + }, + { + "address": "0x1400079eb", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x1400079ee", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140007a50" + } + ], + "successors": [ + "0x140007a50" + ] + }, + { + "address": "0x140007a8f", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007a8f", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [r14 + 0x14]" + }, + { + "address": "0x140007a93", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [r14 + 8]" + }, + { + "address": "0x140007a97", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r13 + 0x28]" + }, + { + "address": "0x140007a9b", + "size": 5, + "mnemonic": "call", + "operands": "0x140007040" + }, + { + "address": "0x140007aa0", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rax" + }, + { + "address": "0x140007aa3", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rbx" + }, + { + "address": "0x140007aa6", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x140007aa9", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3e0" + }, + { + "address": "0x140007aae", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140007ae9" + } + ], + "successors": [ + "0x140007ae9" + ] + }, + { + "address": "0x140007ae9", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007ae9", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x140007aeb", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140007aef" + } + ], + "successors": [ + "0x140007aef" + ] + }, + { + "address": "0x140007a4d", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140007a4d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsi]" + }, + { + "address": "0x140007a50", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [r14 + 8]" + }, + { + "address": "0x140007a54", + "size": 5, + "mnemonic": "call", + "operands": "0x140007040" + }, + { + "address": "0x140007a59", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rsi], rax" + }, + { + "address": "0x140007a5c", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140007ae9" + } + ], + "successors": [ + "0x140007ae9" + ] + }, + { + "address": "0x140007aef", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140007aef", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x50]" + }, + { + "address": "0x140007af4", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x58]" + }, + { + "address": "0x140007af9", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x60]" + }, + { + "address": "0x140007afe", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140007b02", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140007b04", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140007b06", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140007b08", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140007564", + "name": "", + "blocks": [ + { + "address": "0x140007564", + "size": 12, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140007564", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140007566", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000756a", + "size": 5, + "mnemonic": "lea", + "operands": "r9, [rsp + 0x40]" + }, + { + "address": "0x14000756f", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r8" + }, + { + "address": "0x140007572", + "size": 5, + "mnemonic": "call", + "operands": "0x140006544" + }, + { + "address": "0x140007577", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax]" + }, + { + "address": "0x14000757a", + "size": 4, + "mnemonic": "movsxd", + "operands": "rax, dword ptr [rbx + 0x1c]" + }, + { + "address": "0x14000757e", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x40], rcx" + }, + { + "address": "0x140007583", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [rax + rcx + 4]" + }, + { + "address": "0x140007587", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000758b", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000758c", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140007590", + "name": "", + "blocks": [ + { + "address": "0x140007590", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140007590", + "size": 4, + "mnemonic": "movsxd", + "operands": "rdx, dword ptr [rdx + 0x1c]" + }, + { + "address": "0x140007594", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x140007597", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rdx + rax], r8d" + }, + { + "address": "0x14000759b", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000759c", + "name": "", + "blocks": [ + { + "address": "0x14000759c", + "size": 17, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000759c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x1400075a1", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x1400075a2", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400075a6", + "size": 3, + "mnemonic": "mov", + "operands": "edi, r9d" + }, + { + "address": "0x1400075a9", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r8" + }, + { + "address": "0x1400075ac", + "size": 5, + "mnemonic": "lea", + "operands": "r9, [rsp + 0x40]" + }, + { + "address": "0x1400075b1", + "size": 5, + "mnemonic": "call", + "operands": "0x140006544" + }, + { + "address": "0x1400075b6", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax]" + }, + { + "address": "0x1400075b9", + "size": 4, + "mnemonic": "movsxd", + "operands": "rax, dword ptr [rbx + 0x1c]" + }, + { + "address": "0x1400075bd", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x40], rcx" + }, + { + "address": "0x1400075c2", + "size": 4, + "mnemonic": "cmp", + "operands": "edi, dword ptr [rax + rcx + 4]" + }, + { + "address": "0x1400075c6", + "size": 2, + "mnemonic": "jle", + "operands": "0x1400075cc" + }, + { + "address": "0x1400075c8", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rax + rcx + 4], edi" + }, + { + "address": "0x1400075cc", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x1400075d1", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400075d5", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400075d6", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001667c", + "name": "", + "blocks": [ + { + "address": "0x14001667c", + "size": 12, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001667c", + "size": 3, + "mnemonic": "mov", + "operands": "r11, rsp" + }, + { + "address": "0x14001667f", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x140016683", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 3" + }, + { + "address": "0x140016688", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [r11 + 0x10]" + }, + { + "address": "0x14001668c", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [r11 + 8]" + }, + { + "address": "0x140016690", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x38], eax" + }, + { + "address": "0x140016694", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [r11 + 0x18]" + }, + { + "address": "0x140016698", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x40], eax" + }, + { + "address": "0x14001669c", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [r11 + 8]" + }, + { + "address": "0x1400166a0", + "size": 5, + "mnemonic": "call", + "operands": "0x140016634" + }, + { + "address": "0x1400166a5", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400166a9", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400166cc", + "name": "", + "blocks": [ + { + "address": "0x1400166cc", + "size": 16, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400166cc", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rbx" + }, + { + "address": "0x1400166d1", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rsi" + }, + { + "address": "0x1400166d6", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x1400166d7", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x1400166d9", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x1400166db", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x1400166dd", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x1400166df", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x1400166e3", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, ecx" + }, + { + "address": "0x1400166e5", + "size": 3, + "mnemonic": "xor", + "operands": "r15d, r15d" + }, + { + "address": "0x1400166e8", + "size": 5, + "mnemonic": "and", + "operands": "dword ptr [rsp + 0x78], r15d" + }, + { + "address": "0x1400166ed", + "size": 3, + "mnemonic": "mov", + "operands": "r14b, 1" + }, + { + "address": "0x1400166f0", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x70], r14b" + }, + { + "address": "0x1400166f5", + "size": 2, + "mnemonic": "mov", + "operands": "edx, ecx" + }, + { + "address": "0x1400166f7", + "size": 3, + "mnemonic": "sub", + "operands": "edx, 2" + }, + { + "address": "0x1400166fa", + "size": 2, + "mnemonic": "je", + "operands": "0x140016723" + } + ], + "successors": [ + "0x140016723", + "0x1400166fc" + ] + }, + { + "address": "0x140016723", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016723", + "size": 3, + "mnemonic": "sub", + "operands": "ecx, 2" + }, + { + "address": "0x140016726", + "size": 6, + "mnemonic": "je", + "operands": "0x1400167e0" + } + ], + "successors": [ + "0x1400167e0", + "0x14001672c" + ] + }, + { + "address": "0x1400166fc", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400166fc", + "size": 3, + "mnemonic": "sub", + "operands": "edx, 2" + }, + { + "address": "0x1400166ff", + "size": 2, + "mnemonic": "je", + "operands": "0x140016753" + } + ], + "successors": [ + "0x140016753", + "0x140016701" + ] + }, + { + "address": "0x1400167e0", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400167e0", + "size": 7, + "mnemonic": "lea", + "operands": "rdi, [rip + 0x1cf31]" + }, + { + "address": "0x1400167e7", + "size": 3, + "mnemonic": "xor", + "operands": "r13d, r13d" + }, + { + "address": "0x1400167ea", + "size": 3, + "mnemonic": "test", + "operands": "r14b, r14b" + }, + { + "address": "0x1400167ed", + "size": 2, + "mnemonic": "je", + "operands": "0x1400167f9" + } + ], + "successors": [ + "0x1400167f9", + "0x1400167ef" + ] + }, + { + "address": "0x14001672c", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001672c", + "size": 3, + "mnemonic": "sub", + "operands": "ecx, 4" + }, + { + "address": "0x14001672f", + "size": 6, + "mnemonic": "je", + "operands": "0x1400167c5" + } + ], + "successors": [ + "0x1400167c5", + "0x140016735" + ] + }, + { + "address": "0x140016753", + "size": 15, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140016753", + "size": 5, + "mnemonic": "call", + "operands": "0x140011924" + }, + { + "address": "0x140016758", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rax" + }, + { + "address": "0x14001675b", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001675e", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001677d" + }, + { + "address": "0x140016760", + "size": 3, + "mnemonic": "or", + "operands": "eax, 0xffffffff" + }, + { + "address": "0x140016763", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x40]" + }, + { + "address": "0x140016768", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x40]" + }, + { + "address": "0x14001676c", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x48]" + }, + { + "address": "0x140016770", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x140016773", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140016775", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140016777", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140016779", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14001677b", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001677c", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140016701", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016701", + "size": 3, + "mnemonic": "sub", + "operands": "edx, 2" + }, + { + "address": "0x140016704", + "size": 2, + "mnemonic": "je", + "operands": "0x140016723" + } + ], + "successors": [ + "0x140016723", + "0x140016706" + ] + }, + { + "address": "0x1400167f9", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400167f9", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rdi]" + }, + { + "address": "0x1400167fc", + "size": 3, + "mnemonic": "test", + "operands": "r14b, r14b" + }, + { + "address": "0x1400167ff", + "size": 2, + "mnemonic": "je", + "operands": "0x140016813" + } + ], + "successors": [ + "0x140016813", + "0x140016801" + ] + }, + { + "address": "0x1400167ef", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400167ef", + "size": 4, + "mnemonic": "lea", + "operands": "ecx, [r13 + 3]" + }, + { + "address": "0x1400167f3", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca20" + }, + { + "address": "0x1400167f8", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x1400167f9", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rdi]" + }, + { + "address": "0x1400167fc", + "size": 3, + "mnemonic": "test", + "operands": "r14b, r14b" + }, + { + "address": "0x1400167ff", + "size": 2, + "mnemonic": "je", + "operands": "0x140016813" + } + ], + "successors": [ + "0x140016813", + "0x140016801" + ] + }, + { + "address": "0x1400167c5", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400167c5", + "size": 7, + "mnemonic": "lea", + "operands": "rdi, [rip + 0x1cf5c]" + }, + { + "address": "0x1400167cc", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400167e7" + } + ], + "successors": [ + "0x1400167e7" + ] + }, + { + "address": "0x140016735", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016735", + "size": 3, + "mnemonic": "sub", + "operands": "ecx, 9" + }, + { + "address": "0x140016738", + "size": 6, + "mnemonic": "je", + "operands": "0x1400167d7" + } + ], + "successors": [ + "0x1400167d7", + "0x14001673e" + ] + }, + { + "address": "0x140016706", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016706", + "size": 3, + "mnemonic": "sub", + "operands": "edx, 2" + }, + { + "address": "0x140016709", + "size": 2, + "mnemonic": "je", + "operands": "0x140016753" + } + ], + "successors": [ + "0x140016753", + "0x14001670b" + ] + }, + { + "address": "0x140016813", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016813", + "size": 4, + "mnemonic": "cmp", + "operands": "rsi, 1" + }, + { + "address": "0x140016817", + "size": 6, + "mnemonic": "je", + "operands": "0x1400168a8" + } + ], + "successors": [ + "0x1400168a8", + "0x14001681d" + ] + }, + { + "address": "0x140016801", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016801", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x1a838]" + }, + { + "address": "0x140016808", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, eax" + }, + { + "address": "0x14001680a", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0x3f" + }, + { + "address": "0x14001680d", + "size": 3, + "mnemonic": "xor", + "operands": "rsi, rax" + }, + { + "address": "0x140016810", + "size": 3, + "mnemonic": "ror", + "operands": "rsi, cl" + }, + { + "address": "0x140016813", + "size": 4, + "mnemonic": "cmp", + "operands": "rsi, 1" + }, + { + "address": "0x140016817", + "size": 6, + "mnemonic": "je", + "operands": "0x1400168a8" + } + ], + "successors": [ + "0x1400168a8", + "0x14001681d" + ] + }, + { + "address": "0x1400167e7", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400167e7", + "size": 3, + "mnemonic": "xor", + "operands": "r13d, r13d" + }, + { + "address": "0x1400167ea", + "size": 3, + "mnemonic": "test", + "operands": "r14b, r14b" + }, + { + "address": "0x1400167ed", + "size": 2, + "mnemonic": "je", + "operands": "0x1400167f9" + } + ], + "successors": [ + "0x1400167f9", + "0x1400167ef" + ] + }, + { + "address": "0x1400167d7", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400167d7", + "size": 7, + "mnemonic": "lea", + "operands": "rdi, [rip + 0x1cf52]" + }, + { + "address": "0x1400167de", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400167e7" + } + ], + "successors": [ + "0x1400167e7" + ] + }, + { + "address": "0x14001673e", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001673e", + "size": 3, + "mnemonic": "sub", + "operands": "ecx, 6" + }, + { + "address": "0x140016741", + "size": 6, + "mnemonic": "je", + "operands": "0x1400167ce" + } + ], + "successors": [ + "0x1400167ce", + "0x140016747" + ] + }, + { + "address": "0x14001670b", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001670b", + "size": 3, + "mnemonic": "sub", + "operands": "edx, 3" + }, + { + "address": "0x14001670e", + "size": 2, + "mnemonic": "je", + "operands": "0x140016753" + } + ], + "successors": [ + "0x140016753", + "0x140016710" + ] + }, + { + "address": "0x1400168a8", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400168a8", + "size": 6, + "mnemonic": "mov", + "operands": "r12d, 0x910" + }, + { + "address": "0x1400168ae", + "size": 3, + "mnemonic": "test", + "operands": "r14b, r14b" + }, + { + "address": "0x1400168b1", + "size": 2, + "mnemonic": "je", + "operands": "0x1400168bd" + } + ], + "successors": [ + "0x1400168bd", + "0x1400168b3" + ] + }, + { + "address": "0x14001681d", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001681d", + "size": 3, + "mnemonic": "test", + "operands": "rsi, rsi" + }, + { + "address": "0x140016820", + "size": 6, + "mnemonic": "je", + "operands": "0x14001690f" + } + ], + "successors": [ + "0x14001690f", + "0x140016826" + ] + }, + { + "address": "0x1400167ce", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400167ce", + "size": 7, + "mnemonic": "lea", + "operands": "rdi, [rip + 0x1cf4b]" + }, + { + "address": "0x1400167d5", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400167e7" + } + ], + "successors": [ + "0x1400167e7" + ] + }, + { + "address": "0x140016747", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016747", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, 1" + }, + { + "address": "0x14001674a", + "size": 2, + "mnemonic": "je", + "operands": "0x1400167c5" + } + ], + "successors": [ + "0x1400167c5", + "0x14001674c" + ] + }, + { + "address": "0x140016710", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016710", + "size": 3, + "mnemonic": "sub", + "operands": "edx, 4" + }, + { + "address": "0x140016713", + "size": 2, + "mnemonic": "je", + "operands": "0x140016723" + } + ], + "successors": [ + "0x140016723", + "0x140016715" + ] + }, + { + "address": "0x1400168bd", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400168bd", + "size": 4, + "mnemonic": "cmp", + "operands": "rsi, 1" + }, + { + "address": "0x1400168c1", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400168ca" + }, + { + "address": "0x1400168c3", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x1400168c5", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140016763" + } + ], + "successors": [ + "0x140016763" + ] + }, + { + "address": "0x1400168b3", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400168b3", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 3" + }, + { + "address": "0x1400168b8", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca74" + }, + { + "address": "0x1400168bd", + "size": 4, + "mnemonic": "cmp", + "operands": "rsi, 1" + }, + { + "address": "0x1400168c1", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400168ca" + }, + { + "address": "0x1400168c3", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x1400168c5", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140016763" + } + ], + "successors": [ + "0x140016763" + ] + }, + { + "address": "0x14001690f", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001690f", + "size": 3, + "mnemonic": "test", + "operands": "r14b, r14b" + }, + { + "address": "0x140016912", + "size": 2, + "mnemonic": "je", + "operands": "0x14001691c" + } + ], + "successors": [ + "0x14001691c", + "0x140016914" + ] + }, + { + "address": "0x140016826", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016826", + "size": 6, + "mnemonic": "mov", + "operands": "r12d, 0x910" + }, + { + "address": "0x14001682c", + "size": 3, + "mnemonic": "cmp", + "operands": "ebx, 0xb" + }, + { + "address": "0x14001682f", + "size": 2, + "mnemonic": "ja", + "operands": "0x140016866" + } + ], + "successors": [ + "0x140016866", + "0x140016831" + ] + }, + { + "address": "0x14001674c", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001674c", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x14001674e", + "size": 5, + "mnemonic": "jmp", + "operands": "0x1400167e7" + } + ], + "successors": [ + "0x1400167e7" + ] + }, + { + "address": "0x140016715", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016715", + "size": 3, + "mnemonic": "sub", + "operands": "edx, 6" + }, + { + "address": "0x140016718", + "size": 2, + "mnemonic": "je", + "operands": "0x140016723" + } + ], + "successors": [ + "0x140016723", + "0x14001671a" + ] + }, + { + "address": "0x140016763", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140016763", + "size": 5, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x40]" + }, + { + "address": "0x140016768", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x40]" + }, + { + "address": "0x14001676c", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x48]" + }, + { + "address": "0x140016770", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x140016773", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140016775", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140016777", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140016779", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14001677b", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001677c", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001691c", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001691c", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 3" + }, + { + "address": "0x140016921", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ebcc" + }, + { + "address": "0x140016926", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140016927", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140016914", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016914", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rsi + 3]" + }, + { + "address": "0x140016917", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca74" + }, + { + "address": "0x14001691c", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 3" + }, + { + "address": "0x140016921", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ebcc" + }, + { + "address": "0x140016926", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140016927", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140016866", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016866", + "size": 3, + "mnemonic": "cmp", + "operands": "ebx, 8" + }, + { + "address": "0x140016869", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001689c" + }, + { + "address": "0x14001686b", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0xf006]" + }, + { + "address": "0x140016872", + "size": 4, + "mnemonic": "shl", + "operands": "rax, 4" + }, + { + "address": "0x140016876", + "size": 3, + "mnemonic": "add", + "operands": "rax, qword ptr [r15]" + }, + { + "address": "0x140016879", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rip + 0xf000]" + }, + { + "address": "0x140016880", + "size": 4, + "mnemonic": "shl", + "operands": "rcx, 4" + }, + { + "address": "0x140016884", + "size": 3, + "mnemonic": "add", + "operands": "rcx, rax" + }, + { + "address": "0x140016887", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x14001688c", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, rcx" + }, + { + "address": "0x14001688f", + "size": 2, + "mnemonic": "je", + "operands": "0x1400168ae" + } + ], + "successors": [ + "0x1400168ae", + "0x140016891" + ] + }, + { + "address": "0x140016831", + "size": 24, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016831", + "size": 4, + "mnemonic": "bt", + "operands": "r12d, ebx" + }, + { + "address": "0x140016835", + "size": 2, + "mnemonic": "jae", + "operands": "0x140016866" + }, + { + "address": "0x140016837", + "size": 4, + "mnemonic": "mov", + "operands": "r13, qword ptr [r15 + 8]" + }, + { + "address": "0x14001683b", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], r13" + }, + { + "address": "0x140016840", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [r15 + 8], 0" + }, + { + "address": "0x140016845", + "size": 3, + "mnemonic": "cmp", + "operands": "ebx, 8" + }, + { + "address": "0x140016848", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001689c" + }, + { + "address": "0x14001684a", + "size": 5, + "mnemonic": "call", + "operands": "0x1400118c4" + }, + { + "address": "0x14001684f", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rax + 0x10]" + }, + { + "address": "0x140016852", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x78], eax" + }, + { + "address": "0x140016856", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x20], eax" + }, + { + "address": "0x14001685a", + "size": 5, + "mnemonic": "call", + "operands": "0x1400118c4" + }, + { + "address": "0x14001685f", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x10], 0x8c" + }, + { + "address": "0x140016866", + "size": 3, + "mnemonic": "cmp", + "operands": "ebx, 8" + }, + { + "address": "0x140016869", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001689c" + }, + { + "address": "0x14001686b", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0xf006]" + }, + { + "address": "0x140016872", + "size": 4, + "mnemonic": "shl", + "operands": "rax, 4" + }, + { + "address": "0x140016876", + "size": 3, + "mnemonic": "add", + "operands": "rax, qword ptr [r15]" + }, + { + "address": "0x140016879", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rip + 0xf000]" + }, + { + "address": "0x140016880", + "size": 4, + "mnemonic": "shl", + "operands": "rcx, 4" + }, + { + "address": "0x140016884", + "size": 3, + "mnemonic": "add", + "operands": "rcx, rax" + }, + { + "address": "0x140016887", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x14001688c", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, rcx" + }, + { + "address": "0x14001688f", + "size": 2, + "mnemonic": "je", + "operands": "0x1400168ae" + } + ], + "successors": [ + "0x1400168ae", + "0x140016891" + ] + }, + { + "address": "0x14001671a", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001671a", + "size": 3, + "mnemonic": "cmp", + "operands": "edx, 1" + }, + { + "address": "0x14001671d", + "size": 6, + "mnemonic": "jne", + "operands": "0x1400167a5" + }, + { + "address": "0x140016723", + "size": 3, + "mnemonic": "sub", + "operands": "ecx, 2" + }, + { + "address": "0x140016726", + "size": 6, + "mnemonic": "je", + "operands": "0x1400167e0" + } + ], + "successors": [ + "0x1400167e0", + "0x14001672c" + ] + }, + { + "address": "0x1400168ae", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400168ae", + "size": 3, + "mnemonic": "test", + "operands": "r14b, r14b" + }, + { + "address": "0x1400168b1", + "size": 2, + "mnemonic": "je", + "operands": "0x1400168bd" + } + ], + "successors": [ + "0x1400168bd", + "0x1400168b3" + ] + }, + { + "address": "0x140016891", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016891", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rax + 8], 0" + }, + { + "address": "0x140016896", + "size": 4, + "mnemonic": "add", + "operands": "rax, 0x10" + }, + { + "address": "0x14001689a", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140016887" + } + ], + "successors": [ + "0x140016887" + ] + }, + { + "address": "0x140016887", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016887", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x14001688c", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, rcx" + }, + { + "address": "0x14001688f", + "size": 2, + "mnemonic": "je", + "operands": "0x1400168ae" + } + ], + "successors": [ + "0x1400168ae", + "0x140016891" + ] + } + ] + }, + { + "address": "0x1400073b0", + "name": "", + "blocks": [ + { + "address": "0x1400073b0", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400073b0", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x1400073b5", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x1400073ba", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x1400073bf", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x1400073c0", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400073c4", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x29cf5], -1" + }, + { + "address": "0x1400073cb", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400073d4" + }, + { + "address": "0x1400073cd", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x1400073cf", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140007464" + } + ], + "successors": [ + "0x140007464" + ] + }, + { + "address": "0x140007464", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140007464", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140007469", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14000746e", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140007473", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140007477", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140007478", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000735c", + "name": "", + "blocks": [ + { + "address": "0x14000735c", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000735c", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, rdx" + }, + { + "address": "0x14000735f", + "size": 2, + "mnemonic": "jne", + "operands": "0x140007364" + }, + { + "address": "0x140007361", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140007363", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001efd0", + "name": "", + "blocks": [ + { + "address": "0x14001efd0", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001efd0", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, rcx" + }, + { + "address": "0x14001efd3", + "size": 3, + "mnemonic": "test", + "operands": "cl, 7" + }, + { + "address": "0x14001efd6", + "size": 2, + "mnemonic": "je", + "operands": "0x14001efec" + } + ], + "successors": [ + "0x14001efec", + "0x14001efd8" + ] + }, + { + "address": "0x14001efec", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001efec", + "size": 10, + "mnemonic": "movabs", + "operands": "r11, 0x8080808080808080" + }, + { + "address": "0x14001eff6", + "size": 10, + "mnemonic": "movabs", + "operands": "r10, 0xfefefefefefefeff" + }, + { + "address": "0x14001f000", + "size": 4, + "mnemonic": "lea", + "operands": "eax, [edx + ecx]" + }, + { + "address": "0x14001f004", + "size": 5, + "mnemonic": "and", + "operands": "eax, 0xfff" + }, + { + "address": "0x14001f009", + "size": 5, + "mnemonic": "cmp", + "operands": "eax, 0xff8" + }, + { + "address": "0x14001f00e", + "size": 2, + "mnemonic": "ja", + "operands": "0x14001efd8" + } + ], + "successors": [ + "0x14001efd8", + "0x14001f010" + ] + }, + { + "address": "0x14001efd8", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001efd8", + "size": 3, + "mnemonic": "movzx", + "operands": "eax, byte ptr [rcx]" + }, + { + "address": "0x14001efdb", + "size": 3, + "mnemonic": "cmp", + "operands": "al, byte ptr [rdx + rcx]" + }, + { + "address": "0x14001efde", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001f02f" + }, + { + "address": "0x14001efe0", + "size": 3, + "mnemonic": "inc", + "operands": "rcx" + }, + { + "address": "0x14001efe3", + "size": 2, + "mnemonic": "test", + "operands": "al, al" + }, + { + "address": "0x14001efe5", + "size": 2, + "mnemonic": "je", + "operands": "0x14001f02c" + } + ], + "successors": [ + "0x14001f02c", + "0x14001efe7" + ] + }, + { + "address": "0x14001f010", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f010", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x14001f013", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, qword ptr [rdx + rcx]" + }, + { + "address": "0x14001f017", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001efd8" + }, + { + "address": "0x14001f019", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rax + r10]" + }, + { + "address": "0x14001f01d", + "size": 3, + "mnemonic": "not", + "operands": "rax" + }, + { + "address": "0x14001f020", + "size": 4, + "mnemonic": "add", + "operands": "rcx, 8" + }, + { + "address": "0x14001f024", + "size": 3, + "mnemonic": "and", + "operands": "rax, r9" + }, + { + "address": "0x14001f027", + "size": 3, + "mnemonic": "test", + "operands": "r11, rax" + }, + { + "address": "0x14001f02a", + "size": 2, + "mnemonic": "je", + "operands": "0x14001f000" + } + ], + "successors": [ + "0x14001f000", + "0x14001f02c" + ] + }, + { + "address": "0x14001f02c", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001f02c", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001f02e", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001efe7", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001efe7", + "size": 3, + "mnemonic": "test", + "operands": "cl, 7" + }, + { + "address": "0x14001efea", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001efd8" + }, + { + "address": "0x14001efec", + "size": 10, + "mnemonic": "movabs", + "operands": "r11, 0x8080808080808080" + }, + { + "address": "0x14001eff6", + "size": 10, + "mnemonic": "movabs", + "operands": "r10, 0xfefefefefefefeff" + }, + { + "address": "0x14001f000", + "size": 4, + "mnemonic": "lea", + "operands": "eax, [edx + ecx]" + }, + { + "address": "0x14001f004", + "size": 5, + "mnemonic": "and", + "operands": "eax, 0xfff" + }, + { + "address": "0x14001f009", + "size": 5, + "mnemonic": "cmp", + "operands": "eax, 0xff8" + }, + { + "address": "0x14001f00e", + "size": 2, + "mnemonic": "ja", + "operands": "0x14001efd8" + } + ], + "successors": [ + "0x14001efd8", + "0x14001f010" + ] + }, + { + "address": "0x14001f000", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001f000", + "size": 4, + "mnemonic": "lea", + "operands": "eax, [edx + ecx]" + }, + { + "address": "0x14001f004", + "size": 5, + "mnemonic": "and", + "operands": "eax, 0xfff" + }, + { + "address": "0x14001f009", + "size": 5, + "mnemonic": "cmp", + "operands": "eax, 0xff8" + }, + { + "address": "0x14001f00e", + "size": 2, + "mnemonic": "ja", + "operands": "0x14001efd8" + } + ], + "successors": [ + "0x14001efd8", + "0x14001f010" + ] + } + ] + }, + { + "address": "0x14000700c", + "name": "", + "blocks": [ + { + "address": "0x14000700c", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000700c", + "size": 3, + "mnemonic": "jmp", + "operands": "rdx" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400062e8", + "name": "", + "blocks": [ + { + "address": "0x1400062e8", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400062e8", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x1400062ed", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x1400062f2", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x1400062f7", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x1400062f8", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400062fc", + "size": 3, + "mnemonic": "mov", + "operands": "edi, dword ptr [rcx + 0xc]" + }, + { + "address": "0x1400062ff", + "size": 2, + "mnemonic": "mov", + "operands": "esi, edx" + }, + { + "address": "0x140006301", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rcx" + }, + { + "address": "0x140006304", + "size": 2, + "mnemonic": "test", + "operands": "edi, edi" + }, + { + "address": "0x140006306", + "size": 2, + "mnemonic": "je", + "operands": "0x140006333" + } + ], + "successors": [ + "0x140006333", + "0x140006308" + ] + }, + { + "address": "0x140006333", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140006333", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140006335", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000633a", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14000633f", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140006344", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140006348", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140006349", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140006308", + "size": 21, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140006308", + "size": 3, + "mnemonic": "lea", + "operands": "ebx, [rdi - 1]" + }, + { + "address": "0x14000630b", + "size": 2, + "mnemonic": "mov", + "operands": "edi, ebx" + }, + { + "address": "0x14000630d", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140006312", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbx + rbx*4]" + }, + { + "address": "0x140006316", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax + 0x60]" + }, + { + "address": "0x14000631a", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + rdx*4]" + }, + { + "address": "0x14000631e", + "size": 4, + "mnemonic": "movsxd", + "operands": "rax, dword ptr [rbp + 0x10]" + }, + { + "address": "0x140006322", + "size": 3, + "mnemonic": "add", + "operands": "rax, rcx" + }, + { + "address": "0x140006325", + "size": 3, + "mnemonic": "cmp", + "operands": "esi, dword ptr [rax + 4]" + }, + { + "address": "0x140006328", + "size": 2, + "mnemonic": "jle", + "operands": "0x14000632f" + }, + { + "address": "0x14000632a", + "size": 3, + "mnemonic": "cmp", + "operands": "esi, dword ptr [rax + 8]" + }, + { + "address": "0x14000632d", + "size": 2, + "mnemonic": "jle", + "operands": "0x140006335" + }, + { + "address": "0x14000632f", + "size": 2, + "mnemonic": "test", + "operands": "ebx, ebx" + }, + { + "address": "0x140006331", + "size": 2, + "mnemonic": "jne", + "operands": "0x140006308" + }, + { + "address": "0x140006333", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140006335", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000633a", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14000633f", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140006344", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140006348", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140006349", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140006b2c", + "name": "", + "blocks": [ + { + "address": "0x140006b2c", + "size": 39, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006b2c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140006b31", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rdi" + }, + { + "address": "0x140006b36", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [rcx + 0x10]" + }, + { + "address": "0x140006b3a", + "size": 7, + "mnemonic": "lea", + "operands": "rdi, [rip - 0x6b41]" + }, + { + "address": "0x140006b41", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 8], r8" + }, + { + "address": "0x140006b45", + "size": 3, + "mnemonic": "mov", + "operands": "r11, rcx" + }, + { + "address": "0x140006b48", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [r8]" + }, + { + "address": "0x140006b4c", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140006b4f", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + rdi + 0x23d90]" + }, + { + "address": "0x140006b58", + "size": 7, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + rdi + 0x23da0]" + }, + { + "address": "0x140006b5f", + "size": 3, + "mnemonic": "sub", + "operands": "r8, rax" + }, + { + "address": "0x140006b62", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r8 - 4]" + }, + { + "address": "0x140006b66", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140006b68", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r11 + 0x18], eax" + }, + { + "address": "0x140006b6c", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r11 + 8], r8" + }, + { + "address": "0x140006b70", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [r8]" + }, + { + "address": "0x140006b74", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140006b77", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + rdi + 0x23d90]" + }, + { + "address": "0x140006b80", + "size": 7, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + rdi + 0x23da0]" + }, + { + "address": "0x140006b87", + "size": 3, + "mnemonic": "sub", + "operands": "r8, rax" + }, + { + "address": "0x140006b8a", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r8 - 4]" + }, + { + "address": "0x140006b8e", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r11 + 8], r8" + }, + { + "address": "0x140006b92", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140006b94", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r11 + 0x1c], eax" + }, + { + "address": "0x140006b98", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [r8]" + }, + { + "address": "0x140006b9c", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140006b9f", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + rdi + 0x23d90]" + }, + { + "address": "0x140006ba8", + "size": 7, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + rdi + 0x23da0]" + }, + { + "address": "0x140006baf", + "size": 3, + "mnemonic": "sub", + "operands": "r8, rax" + }, + { + "address": "0x140006bb2", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r8 - 4]" + }, + { + "address": "0x140006bb6", + "size": 4, + "mnemonic": "lea", + "operands": "r10, [r8 + 4]" + }, + { + "address": "0x140006bba", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r11 + 8], r8" + }, + { + "address": "0x140006bbe", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140006bc0", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rdx + 8], 0" + }, + { + "address": "0x140006bc4", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r11 + 0x20], eax" + }, + { + "address": "0x140006bc8", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [r8]" + }, + { + "address": "0x140006bcb", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r11 + 8], r10" + }, + { + "address": "0x140006bcf", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r11 + 0x24], eax" + }, + { + "address": "0x140006bd3", + "size": 6, + "mnemonic": "je", + "operands": "0x140006d0a" + } + ], + "successors": [ + "0x140006d0a", + "0x140006bd9" + ] + }, + { + "address": "0x140006d0a", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140006d0a", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 8]" + }, + { + "address": "0x140006d0f", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x10]" + }, + { + "address": "0x140006d14", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140006bd9", + "size": 78, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140006bd9", + "size": 3, + "mnemonic": "mov", + "operands": "ebx, dword ptr [rdx + 8]" + }, + { + "address": "0x140006bdc", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [r10]" + }, + { + "address": "0x140006be0", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r10" + }, + { + "address": "0x140006be3", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140006be6", + "size": 9, + "mnemonic": "movsx", + "operands": "r9, byte ptr [rcx + rdi + 0x23d90]" + }, + { + "address": "0x140006bef", + "size": 7, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + rdi + 0x23da0]" + }, + { + "address": "0x140006bf6", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x140006bf9", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x140006bfc", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r11 + 8], rdx" + }, + { + "address": "0x140006c00", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140006c02", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r11 + 0x18], eax" + }, + { + "address": "0x140006c06", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140006c09", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r10" + }, + { + "address": "0x140006c0c", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140006c0f", + "size": 9, + "mnemonic": "movsx", + "operands": "r8, byte ptr [rcx + rdi + 0x23d90]" + }, + { + "address": "0x140006c18", + "size": 7, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + rdi + 0x23da0]" + }, + { + "address": "0x140006c1f", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r8" + }, + { + "address": "0x140006c22", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x140006c25", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x140006c28", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r11 + 8], rdx" + }, + { + "address": "0x140006c2c", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140006c2e", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r11 + 0x1c], eax" + }, + { + "address": "0x140006c32", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140006c35", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140006c38", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + rdi + 0x23d90]" + }, + { + "address": "0x140006c41", + "size": 7, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + rdi + 0x23da0]" + }, + { + "address": "0x140006c48", + "size": 3, + "mnemonic": "sub", + "operands": "r10, rax" + }, + { + "address": "0x140006c4b", + "size": 3, + "mnemonic": "sub", + "operands": "r10, r8" + }, + { + "address": "0x140006c4e", + "size": 3, + "mnemonic": "sub", + "operands": "r10, r9" + }, + { + "address": "0x140006c51", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r10 - 4]" + }, + { + "address": "0x140006c55", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r11 + 8], r10" + }, + { + "address": "0x140006c59", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140006c5b", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r11 + 0x20], eax" + }, + { + "address": "0x140006c5f", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [r10]" + }, + { + "address": "0x140006c62", + "size": 4, + "mnemonic": "add", + "operands": "r10, 4" + }, + { + "address": "0x140006c66", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r11 + 8], r10" + }, + { + "address": "0x140006c6a", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r10" + }, + { + "address": "0x140006c6d", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r11 + 0x24], eax" + }, + { + "address": "0x140006c71", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [r10]" + }, + { + "address": "0x140006c75", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140006c78", + "size": 9, + "mnemonic": "movsx", + "operands": "r9, byte ptr [rcx + rdi + 0x23d90]" + }, + { + "address": "0x140006c81", + "size": 7, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + rdi + 0x23da0]" + }, + { + "address": "0x140006c88", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x140006c8b", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x140006c8e", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r11 + 8], rdx" + }, + { + "address": "0x140006c92", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140006c94", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r11 + 0x18], eax" + }, + { + "address": "0x140006c98", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140006c9b", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r10" + }, + { + "address": "0x140006c9e", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140006ca1", + "size": 9, + "mnemonic": "movsx", + "operands": "r8, byte ptr [rcx + rdi + 0x23d90]" + }, + { + "address": "0x140006caa", + "size": 7, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + rdi + 0x23da0]" + }, + { + "address": "0x140006cb1", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r8" + }, + { + "address": "0x140006cb4", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x140006cb7", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x140006cba", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140006cbc", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r11 + 8], rdx" + }, + { + "address": "0x140006cc0", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r11 + 0x1c], eax" + }, + { + "address": "0x140006cc4", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x140006cc7", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140006cca", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + rdi + 0x23d90]" + }, + { + "address": "0x140006cd3", + "size": 7, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + rdi + 0x23da0]" + }, + { + "address": "0x140006cda", + "size": 3, + "mnemonic": "sub", + "operands": "r10, rax" + }, + { + "address": "0x140006cdd", + "size": 3, + "mnemonic": "sub", + "operands": "r10, r8" + }, + { + "address": "0x140006ce0", + "size": 3, + "mnemonic": "sub", + "operands": "r10, r9" + }, + { + "address": "0x140006ce3", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r10 - 4]" + }, + { + "address": "0x140006ce7", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x140006ce9", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r11 + 8], r10" + }, + { + "address": "0x140006ced", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r11 + 0x20], eax" + }, + { + "address": "0x140006cf1", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [r10]" + }, + { + "address": "0x140006cf4", + "size": 4, + "mnemonic": "add", + "operands": "r10, 4" + }, + { + "address": "0x140006cf8", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r11 + 8], r10" + }, + { + "address": "0x140006cfc", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [r11 + 0x24], eax" + }, + { + "address": "0x140006d00", + "size": 4, + "mnemonic": "sub", + "operands": "rbx, 1" + }, + { + "address": "0x140006d04", + "size": 6, + "mnemonic": "jne", + "operands": "0x140006bdc" + }, + { + "address": "0x140006d0a", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 8]" + }, + { + "address": "0x140006d0f", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x10]" + }, + { + "address": "0x140006d14", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000ac30", + "name": "", + "blocks": [ + { + "address": "0x14000ac30", + "size": 16, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ac30", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbx" + }, + { + "address": "0x14000ac35", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x14000ac3a", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000ac3b", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000ac3f", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rcx]" + }, + { + "address": "0x14000ac42", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x14000ac44", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14000ac47", + "size": 3, + "mnemonic": "test", + "operands": "rsi, rsi" + }, + { + "address": "0x14000ac4a", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000ac87" + }, + { + "address": "0x14000ac4c", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x154a6]" + }, + { + "address": "0x14000ac52", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x30], eax" + }, + { + "address": "0x14000ac56", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbx + 0x10], dil" + }, + { + "address": "0x14000ac5a", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000ac66" + }, + { + "address": "0x14000ac5c", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbx + 8], rdi" + }, + { + "address": "0x14000ac60", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbx + 0x10], 1" + }, + { + "address": "0x14000ac64", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000ac6a" + } + ], + "successors": [ + "0x14000ac6a" + ] + }, + { + "address": "0x14000ac6a", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000ac6a", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rdi" + }, + { + "address": "0x14000ac6d", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x30]" + }, + { + "address": "0x14000ac72", + "size": 5, + "mnemonic": "call", + "operands": "0x1400119b4" + }, + { + "address": "0x14000ac77", + "size": 4, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rsp + 0x30]" + }, + { + "address": "0x14000ac7b", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rax" + }, + { + "address": "0x14000ac7e", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rbx], rax" + }, + { + "address": "0x14000ac81", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x15479]" + }, + { + "address": "0x14000ac87", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14000ac8c", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsi" + }, + { + "address": "0x14000ac8f", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14000ac94", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000ac98", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000ac99", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000ac9c", + "name": "", + "blocks": [ + { + "address": "0x14000ac9c", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ac9c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000aca1", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rsi" + }, + { + "address": "0x14000aca6", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000aca7", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000acab", + "size": 2, + "mnemonic": "xor", + "operands": "ebx, ebx" + }, + { + "address": "0x14000acad", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x14000acb0", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rcx" + }, + { + "address": "0x14000acb3", + "size": 3, + "mnemonic": "cmp", + "operands": "byte ptr [rdx + 0x10], bl" + }, + { + "address": "0x14000acb6", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000acd0" + }, + { + "address": "0x14000acb8", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1543a]" + }, + { + "address": "0x14000acbe", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, eax" + }, + { + "address": "0x14000acc0", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rdi + 8], rbx" + }, + { + "address": "0x14000acc4", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rdi + 0x10], 1" + }, + { + "address": "0x14000acc8", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x15432]" + }, + { + "address": "0x14000acce", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000acd4" + } + ], + "successors": [ + "0x14000acd4" + ] + }, + { + "address": "0x14000acd4", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000acd4", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rsi + rbx*8]" + }, + { + "address": "0x14000acd8", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000acdd", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14000ace2", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000ace6", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000ace7", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400119b4", + "name": "", + "blocks": [ + { + "address": "0x1400119b4", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400119b4", + "size": 2, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x1400119b6", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x1400119ba", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], 0xfffffffffffffffe" + }, + { + "address": "0x1400119c3", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x40], rbx" + }, + { + "address": "0x1400119c8", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x1400119cb", + "size": 2, + "mnemonic": "xor", + "operands": "ebx, ebx" + }, + { + "address": "0x1400119cd", + "size": 6, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rip + 0x1f8ed]" + }, + { + "address": "0x1400119d3", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, -1" + }, + { + "address": "0x1400119d6", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400119dc" + }, + { + "address": "0x1400119d8", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ebx" + }, + { + "address": "0x1400119da", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400119e2" + } + ], + "successors": [ + "0x1400119e2" + ] + }, + { + "address": "0x1400119e2", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400119e2", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, -1" + }, + { + "address": "0x1400119e6", + "size": 2, + "mnemonic": "je", + "operands": "0x140011a01" + } + ], + "successors": [ + "0x140011a01", + "0x1400119e8" + ] + }, + { + "address": "0x140011a01", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140011a01", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140011a04", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140011a09", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140011a0d", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140011a0e", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400119e8", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400119e8", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x1400119eb", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400119f7" + }, + { + "address": "0x1400119ed", + "size": 5, + "mnemonic": "call", + "operands": "0x1400117a4" + }, + { + "address": "0x1400119f2", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x1400119f5", + "size": 2, + "mnemonic": "je", + "operands": "0x140011a01" + } + ], + "successors": [ + "0x140011a01", + "0x1400119f7" + ] + }, + { + "address": "0x1400119f7", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400119f7", + "size": 7, + "mnemonic": "imul", + "operands": "rbx, rdi, 0x3c8" + }, + { + "address": "0x1400119fe", + "size": 3, + "mnemonic": "add", + "operands": "rbx, rax" + }, + { + "address": "0x140011a01", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140011a04", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140011a09", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140011a0d", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140011a0e", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000b3cc", + "name": "", + "blocks": [ + { + "address": "0x14000b3cc", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b3cc", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000b3d1", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r9" + }, + { + "address": "0x14000b3d6", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000b3d7", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000b3db", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r9" + }, + { + "address": "0x14000b3de", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r8" + }, + { + "address": "0x14000b3e1", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdx]" + }, + { + "address": "0x14000b3e4", + "size": 5, + "mnemonic": "call", + "operands": "0x14000b1f8" + }, + { + "address": "0x14000b3e9", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14000b3ea", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rbx + 8]" + }, + { + "address": "0x14000b3ee", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx]" + }, + { + "address": "0x14000b3f1", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax]" + }, + { + "address": "0x14000b3f4", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14000b3f7", + "size": 2, + "mnemonic": "je", + "operands": "0x14000b455" + } + ], + "successors": [ + "0x14000b455", + "0x14000b3f9" + ] + }, + { + "address": "0x14000b455", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000b455", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdi]" + }, + { + "address": "0x14000b458", + "size": 5, + "mnemonic": "call", + "operands": "0x14000b204" + }, + { + "address": "0x14000b45d", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000b462", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000b466", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000b467", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000b3f9", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b3f9", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rcx + 0x14]" + }, + { + "address": "0x14000b3fc", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14000b3fd", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ecx" + }, + { + "address": "0x14000b3ff", + "size": 3, + "mnemonic": "shr", + "operands": "eax, 0xd" + }, + { + "address": "0x14000b402", + "size": 2, + "mnemonic": "test", + "operands": "al, 1" + }, + { + "address": "0x14000b404", + "size": 2, + "mnemonic": "je", + "operands": "0x14000b455" + } + ], + "successors": [ + "0x14000b455", + "0x14000b406" + ] + }, + { + "address": "0x14000b406", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b406", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ecx" + }, + { + "address": "0x14000b408", + "size": 2, + "mnemonic": "and", + "operands": "al, 3" + }, + { + "address": "0x14000b40a", + "size": 2, + "mnemonic": "cmp", + "operands": "al, 2" + }, + { + "address": "0x14000b40c", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000b413" + }, + { + "address": "0x14000b40e", + "size": 3, + "mnemonic": "test", + "operands": "cl, 0xc0" + }, + { + "address": "0x14000b411", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000b41d" + }, + { + "address": "0x14000b413", + "size": 4, + "mnemonic": "bt", + "operands": "ecx, 0xb" + }, + { + "address": "0x14000b417", + "size": 2, + "mnemonic": "jb", + "operands": "0x14000b41d" + } + ], + "successors": [ + "0x14000b41d", + "0x14000b419" + ] + }, + { + "address": "0x14000b41d", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b41d", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx + 0x10]" + }, + { + "address": "0x14000b421", + "size": 3, + "mnemonic": "cmp", + "operands": "byte ptr [rax], 0" + }, + { + "address": "0x14000b424", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000b436" + }, + { + "address": "0x14000b426", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx]" + }, + { + "address": "0x14000b429", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax]" + }, + { + "address": "0x14000b42c", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rcx + 0x14]" + }, + { + "address": "0x14000b42f", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14000b430", + "size": 2, + "mnemonic": "shr", + "operands": "eax, 1" + }, + { + "address": "0x14000b432", + "size": 2, + "mnemonic": "test", + "operands": "al, 1" + }, + { + "address": "0x14000b434", + "size": 2, + "mnemonic": "je", + "operands": "0x14000b455" + } + ], + "successors": [ + "0x14000b455", + "0x14000b436" + ] + }, + { + "address": "0x14000b419", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b419", + "size": 2, + "mnemonic": "inc", + "operands": "dword ptr [rdx]" + }, + { + "address": "0x14000b41b", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000b455" + } + ], + "successors": [ + "0x14000b455" + ] + }, + { + "address": "0x14000b436", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b436", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx]" + }, + { + "address": "0x14000b439", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx]" + }, + { + "address": "0x14000b43c", + "size": 5, + "mnemonic": "call", + "operands": "0x14000b678" + }, + { + "address": "0x14000b441", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, -1" + }, + { + "address": "0x14000b444", + "size": 2, + "mnemonic": "je", + "operands": "0x14000b44e" + } + ], + "successors": [ + "0x14000b44e", + "0x14000b446" + ] + }, + { + "address": "0x14000b44e", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000b44e", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx + 0x18]" + }, + { + "address": "0x14000b452", + "size": 3, + "mnemonic": "or", + "operands": "dword ptr [rax], 0xffffffff" + }, + { + "address": "0x14000b455", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdi]" + }, + { + "address": "0x14000b458", + "size": 5, + "mnemonic": "call", + "operands": "0x14000b204" + }, + { + "address": "0x14000b45d", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000b462", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000b466", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000b467", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000b446", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b446", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx + 8]" + }, + { + "address": "0x14000b44a", + "size": 2, + "mnemonic": "inc", + "operands": "dword ptr [rax]" + }, + { + "address": "0x14000b44c", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000b455" + } + ], + "successors": [ + "0x14000b455" + ] + } + ] + }, + { + "address": "0x140011924", + "name": "", + "blocks": [ + { + "address": "0x140011924", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011924", + "size": 2, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140011926", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001192a", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], 0xfffffffffffffffe" + }, + { + "address": "0x140011933", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x40], rbx" + }, + { + "address": "0x140011938", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x14001193a", + "size": 7, + "mnemonic": "cmp", + "operands": "byte ptr [rip + 0x218ef], dil" + }, + { + "address": "0x140011941", + "size": 2, + "mnemonic": "je", + "operands": "0x14001196d" + } + ], + "successors": [ + "0x14001196d", + "0x140011943" + ] + }, + { + "address": "0x14001196d", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001196d", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xe785]" + }, + { + "address": "0x140011973", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, eax" + }, + { + "address": "0x140011975", + "size": 6, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rip + 0x1f945]" + }, + { + "address": "0x14001197b", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, -1" + }, + { + "address": "0x14001197e", + "size": 2, + "mnemonic": "jne", + "operands": "0x140011985" + }, + { + "address": "0x140011980", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdi" + }, + { + "address": "0x140011983", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001198b" + } + ], + "successors": [ + "0x14001198b" + ] + }, + { + "address": "0x140011943", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011943", + "size": 6, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rip + 0x1f977]" + }, + { + "address": "0x140011949", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, -1" + }, + { + "address": "0x14001194c", + "size": 2, + "mnemonic": "jne", + "operands": "0x140011952" + }, + { + "address": "0x14001194e", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x140011950", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140011958" + } + ], + "successors": [ + "0x140011958" + ] + }, + { + "address": "0x14001198b", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001198b", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, -1" + }, + { + "address": "0x14001198f", + "size": 2, + "mnemonic": "je", + "operands": "0x14001199e" + } + ], + "successors": [ + "0x14001199e", + "0x140011991" + ] + }, + { + "address": "0x140011958", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011958", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, -1" + }, + { + "address": "0x14001195c", + "size": 2, + "mnemonic": "je", + "operands": "0x1400119a6" + } + ], + "successors": [ + "0x1400119a6", + "0x14001195e" + ] + }, + { + "address": "0x14001199e", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001199e", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x1400119a0", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xe75a]" + }, + { + "address": "0x1400119a6", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdi" + }, + { + "address": "0x1400119a9", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x1400119ae", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x1400119b2", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400119b3", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140011991", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140011991", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140011994", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001199b" + }, + { + "address": "0x140011996", + "size": 5, + "mnemonic": "call", + "operands": "0x1400117a4" + }, + { + "address": "0x14001199b", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rax" + }, + { + "address": "0x14001199e", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x1400119a0", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xe75a]" + }, + { + "address": "0x1400119a6", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdi" + }, + { + "address": "0x1400119a9", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x1400119ae", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x1400119b2", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400119b3", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400119a6", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400119a6", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdi" + }, + { + "address": "0x1400119a9", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x1400119ae", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x1400119b2", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400119b3", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001195e", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001195e", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140011961", + "size": 2, + "mnemonic": "jne", + "operands": "0x140011968" + }, + { + "address": "0x140011963", + "size": 5, + "mnemonic": "call", + "operands": "0x1400117a4" + }, + { + "address": "0x140011968", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rax" + }, + { + "address": "0x14001196b", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400119a6" + } + ], + "successors": [ + "0x1400119a6" + ] + } + ] + }, + { + "address": "0x14000ae60", + "name": "", + "blocks": [ + { + "address": "0x14000ae60", + "size": 25, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ae60", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000ae65", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000ae66", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14000ae69", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x70" + }, + { + "address": "0x14000ae6d", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rbp - 0x40], 0" + }, + { + "address": "0x14000ae72", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x28377], 0" + }, + { + "address": "0x14000ae79", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x30], 0" + }, + { + "address": "0x14000ae7d", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 0" + }, + { + "address": "0x14000ae81", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x14000ae85", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x14000ae89", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000ae9b" + }, + { + "address": "0x14000ae8b", + "size": 7, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rip + 0x26596]" + }, + { + "address": "0x14000ae92", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 1" + }, + { + "address": "0x14000ae96", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp - 0x28], xmm0" + }, + { + "address": "0x14000ae9b", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp - 0x40]" + }, + { + "address": "0x14000ae9f", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x14000aea4", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp + 0x30]" + }, + { + "address": "0x14000aea8", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14000aead", + "size": 5, + "mnemonic": "call", + "operands": "0x14000aefc" + }, + { + "address": "0x14000aeb2", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x18], 2" + }, + { + "address": "0x14000aeb6", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000aec3" + }, + { + "address": "0x14000aeb8", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbp - 0x40]" + }, + { + "address": "0x14000aebc", + "size": 7, + "mnemonic": "and", + "operands": "dword ptr [rax + 0x3a8], 0xfffffffd" + }, + { + "address": "0x14000aec3", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x14000aec7", + "size": 2, + "mnemonic": "je", + "operands": "0x14000aed8" + } + ], + "successors": [ + "0x14000aed8", + "0x14000aec9" + ] + } + ] + }, + { + "address": "0x140011c00", + "name": "", + "blocks": [ + { + "address": "0x140011c00", + "size": 16, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011c00", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140011c05", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x140011c0a", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rsi" + }, + { + "address": "0x140011c0f", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140011c10", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140011c12", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140011c14", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140011c16", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140011c18", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140011c1c", + "size": 4, + "mnemonic": "or", + "operands": "rax, 0xffffffffffffffff" + }, + { + "address": "0x140011c20", + "size": 3, + "mnemonic": "mov", + "operands": "r12d, ecx" + }, + { + "address": "0x140011c23", + "size": 3, + "mnemonic": "mov", + "operands": "r14, r9" + }, + { + "address": "0x140011c26", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, r8" + }, + { + "address": "0x140011c29", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rdx" + }, + { + "address": "0x140011c2c", + "size": 3, + "mnemonic": "cmp", + "operands": "r8, r9" + }, + { + "address": "0x140011c2f", + "size": 6, + "mnemonic": "je", + "operands": "0x140011cf0" + } + ], + "successors": [ + "0x140011cf0", + "0x140011c35" + ] + }, + { + "address": "0x140011cf0", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011cf0", + "size": 2, + "mnemonic": "xor", + "operands": "ebx, ebx" + }, + { + "address": "0x140011cf2", + "size": 5, + "mnemonic": "mov", + "operands": "edi, 0xe" + }, + { + "address": "0x140011cf7", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, edi" + }, + { + "address": "0x140011cf9", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca20" + }, + { + "address": "0x140011cfe", + "size": 5, + "mnemonic": "and", + "operands": "dword ptr [rsp + 0x60], 0" + }, + { + "address": "0x140011d03", + "size": 7, + "mnemonic": "lea", + "operands": "rsi, [rip + 0x242f6]" + }, + { + "address": "0x140011d0a", + "size": 5, + "mnemonic": "mov", + "operands": "ebp, 0x100" + }, + { + "address": "0x140011d0f", + "size": 5, + "mnemonic": "lea", + "operands": "r9, [rsp + 0x60]" + }, + { + "address": "0x140011d14", + "size": 2, + "mnemonic": "mov", + "operands": "edx, ebp" + }, + { + "address": "0x140011d16", + "size": 4, + "mnemonic": "lea", + "operands": "r8d, [rdi - 0xa]" + }, + { + "address": "0x140011d1a", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x140011d1d", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xe48d]" + }, + { + "address": "0x140011d23", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140011d25", + "size": 6, + "mnemonic": "je", + "operands": "0x140011dac" + } + ], + "successors": [ + "0x140011dac", + "0x140011d2b" + ] + }, + { + "address": "0x140011c35", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011c35", + "size": 7, + "mnemonic": "lea", + "operands": "r13, [rip - 0x11c3c]" + }, + { + "address": "0x140011c3c", + "size": 2, + "mnemonic": "mov", + "operands": "edi, dword ptr [rsi]" + }, + { + "address": "0x140011c3e", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r13 + rdi*8 + 0x33240]" + }, + { + "address": "0x140011c46", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140011c47", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x140011c4a", + "size": 2, + "mnemonic": "je", + "operands": "0x140011c5a" + } + ], + "successors": [ + "0x140011c5a", + "0x140011c4c" + ] + }, + { + "address": "0x140011dac", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011dac", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140011db1", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140011d2b", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011d2b", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x140011d2e", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140011d31", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, 0xffffffffffffffff" + }, + { + "address": "0x140011d38", + "size": 4, + "mnemonic": "cmove", + "operands": "rax, rcx" + }, + { + "address": "0x140011d3c", + "size": 4, + "mnemonic": "xchg", + "operands": "qword ptr [rsi + r12*8], rax" + }, + { + "address": "0x140011d40", + "size": 5, + "mnemonic": "lea", + "operands": "r9, [rsp + 0x60]" + }, + { + "address": "0x140011d45", + "size": 2, + "mnemonic": "mov", + "operands": "edx, ebp" + }, + { + "address": "0x140011d47", + "size": 4, + "mnemonic": "lea", + "operands": "r8d, [rdi - 0xc]" + }, + { + "address": "0x140011d4b", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x140011d4e", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xe45c]" + }, + { + "address": "0x140011d54", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140011d56", + "size": 2, + "mnemonic": "je", + "operands": "0x140011dac" + } + ], + "successors": [ + "0x140011dac", + "0x140011d58" + ] + }, + { + "address": "0x140011c5a", + "size": 18, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011c5a", + "size": 8, + "mnemonic": "mov", + "operands": "rbp, qword ptr [r13 + rdi*8 + 0x262a0]" + }, + { + "address": "0x140011c62", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140011c64", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbp" + }, + { + "address": "0x140011c67", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x800" + }, + { + "address": "0x140011c6d", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xe4cd]" + }, + { + "address": "0x140011c73", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x140011c76", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140011c79", + "size": 6, + "mnemonic": "jne", + "operands": "0x140011d7f" + }, + { + "address": "0x140011c7f", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xe473]" + }, + { + "address": "0x140011c85", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 0x57" + }, + { + "address": "0x140011c88", + "size": 2, + "mnemonic": "jne", + "operands": "0x140011cd3" + }, + { + "address": "0x140011c8a", + "size": 3, + "mnemonic": "lea", + "operands": "ebx, [rax - 0x50]" + }, + { + "address": "0x140011c8d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbp" + }, + { + "address": "0x140011c90", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, ebx" + }, + { + "address": "0x140011c93", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x13106]" + }, + { + "address": "0x140011c9a", + "size": 5, + "mnemonic": "call", + "operands": "0x140011460" + }, + { + "address": "0x140011c9f", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140011ca1", + "size": 2, + "mnemonic": "je", + "operands": "0x140011cd3" + } + ], + "successors": [ + "0x140011cd3", + "0x140011ca3" + ] + }, + { + "address": "0x140011c4c", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011c4c", + "size": 3, + "mnemonic": "cmp", + "operands": "rbx, rax" + }, + { + "address": "0x140011c4f", + "size": 6, + "mnemonic": "jne", + "operands": "0x140011d98" + }, + { + "address": "0x140011c55", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140011ce3" + } + ], + "successors": [ + "0x140011ce3" + ] + }, + { + "address": "0x140011d58", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140011d58", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, edi" + }, + { + "address": "0x140011d5a", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca74" + }, + { + "address": "0x140011d5f", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x58]" + }, + { + "address": "0x140011d64", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140011d67", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x50]" + }, + { + "address": "0x140011d6c", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x68]" + }, + { + "address": "0x140011d71", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140011d75", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140011d77", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140011d79", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140011d7b", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140011d7d", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140011d7e", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140011cd3", + "size": 20, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011cd3", + "size": 4, + "mnemonic": "or", + "operands": "rax, 0xffffffffffffffff" + }, + { + "address": "0x140011cd7", + "size": 8, + "mnemonic": "xchg", + "operands": "qword ptr [r13 + rdi*8 + 0x33240], rax" + }, + { + "address": "0x140011cdf", + "size": 4, + "mnemonic": "or", + "operands": "rax, 0xffffffffffffffff" + }, + { + "address": "0x140011ce3", + "size": 4, + "mnemonic": "add", + "operands": "rsi, 4" + }, + { + "address": "0x140011ce7", + "size": 3, + "mnemonic": "cmp", + "operands": "rsi, r14" + }, + { + "address": "0x140011cea", + "size": 6, + "mnemonic": "jne", + "operands": "0x140011c3c" + }, + { + "address": "0x140011cf0", + "size": 2, + "mnemonic": "xor", + "operands": "ebx, ebx" + }, + { + "address": "0x140011cf2", + "size": 5, + "mnemonic": "mov", + "operands": "edi, 0xe" + }, + { + "address": "0x140011cf7", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, edi" + }, + { + "address": "0x140011cf9", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca20" + }, + { + "address": "0x140011cfe", + "size": 5, + "mnemonic": "and", + "operands": "dword ptr [rsp + 0x60], 0" + }, + { + "address": "0x140011d03", + "size": 7, + "mnemonic": "lea", + "operands": "rsi, [rip + 0x242f6]" + }, + { + "address": "0x140011d0a", + "size": 5, + "mnemonic": "mov", + "operands": "ebp, 0x100" + }, + { + "address": "0x140011d0f", + "size": 5, + "mnemonic": "lea", + "operands": "r9, [rsp + 0x60]" + }, + { + "address": "0x140011d14", + "size": 2, + "mnemonic": "mov", + "operands": "edx, ebp" + }, + { + "address": "0x140011d16", + "size": 4, + "mnemonic": "lea", + "operands": "r8d, [rdi - 0xa]" + }, + { + "address": "0x140011d1a", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x140011d1d", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xe48d]" + }, + { + "address": "0x140011d23", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140011d25", + "size": 6, + "mnemonic": "je", + "operands": "0x140011dac" + } + ], + "successors": [ + "0x140011dac", + "0x140011d2b" + ] + }, + { + "address": "0x140011ca3", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011ca3", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, ebx" + }, + { + "address": "0x140011ca6", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x14bcb]" + }, + { + "address": "0x140011cad", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbp" + }, + { + "address": "0x140011cb0", + "size": 5, + "mnemonic": "call", + "operands": "0x140011460" + }, + { + "address": "0x140011cb5", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140011cb7", + "size": 2, + "mnemonic": "je", + "operands": "0x140011cd3" + } + ], + "successors": [ + "0x140011cd3", + "0x140011cb9" + ] + }, + { + "address": "0x140011ce3", + "size": 17, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011ce3", + "size": 4, + "mnemonic": "add", + "operands": "rsi, 4" + }, + { + "address": "0x140011ce7", + "size": 3, + "mnemonic": "cmp", + "operands": "rsi, r14" + }, + { + "address": "0x140011cea", + "size": 6, + "mnemonic": "jne", + "operands": "0x140011c3c" + }, + { + "address": "0x140011cf0", + "size": 2, + "mnemonic": "xor", + "operands": "ebx, ebx" + }, + { + "address": "0x140011cf2", + "size": 5, + "mnemonic": "mov", + "operands": "edi, 0xe" + }, + { + "address": "0x140011cf7", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, edi" + }, + { + "address": "0x140011cf9", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca20" + }, + { + "address": "0x140011cfe", + "size": 5, + "mnemonic": "and", + "operands": "dword ptr [rsp + 0x60], 0" + }, + { + "address": "0x140011d03", + "size": 7, + "mnemonic": "lea", + "operands": "rsi, [rip + 0x242f6]" + }, + { + "address": "0x140011d0a", + "size": 5, + "mnemonic": "mov", + "operands": "ebp, 0x100" + }, + { + "address": "0x140011d0f", + "size": 5, + "mnemonic": "lea", + "operands": "r9, [rsp + 0x60]" + }, + { + "address": "0x140011d14", + "size": 2, + "mnemonic": "mov", + "operands": "edx, ebp" + }, + { + "address": "0x140011d16", + "size": 4, + "mnemonic": "lea", + "operands": "r8d, [rdi - 0xa]" + }, + { + "address": "0x140011d1a", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x140011d1d", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xe48d]" + }, + { + "address": "0x140011d23", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140011d25", + "size": 6, + "mnemonic": "je", + "operands": "0x140011dac" + } + ], + "successors": [ + "0x140011dac", + "0x140011d2b" + ] + }, + { + "address": "0x140011cb9", + "size": 27, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011cb9", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x140011cbc", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140011cbe", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbp" + }, + { + "address": "0x140011cc1", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xe479]" + }, + { + "address": "0x140011cc7", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x140011cca", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140011ccd", + "size": 6, + "mnemonic": "jne", + "operands": "0x140011d7f" + }, + { + "address": "0x140011cd3", + "size": 4, + "mnemonic": "or", + "operands": "rax, 0xffffffffffffffff" + }, + { + "address": "0x140011cd7", + "size": 8, + "mnemonic": "xchg", + "operands": "qword ptr [r13 + rdi*8 + 0x33240], rax" + }, + { + "address": "0x140011cdf", + "size": 4, + "mnemonic": "or", + "operands": "rax, 0xffffffffffffffff" + }, + { + "address": "0x140011ce3", + "size": 4, + "mnemonic": "add", + "operands": "rsi, 4" + }, + { + "address": "0x140011ce7", + "size": 3, + "mnemonic": "cmp", + "operands": "rsi, r14" + }, + { + "address": "0x140011cea", + "size": 6, + "mnemonic": "jne", + "operands": "0x140011c3c" + }, + { + "address": "0x140011cf0", + "size": 2, + "mnemonic": "xor", + "operands": "ebx, ebx" + }, + { + "address": "0x140011cf2", + "size": 5, + "mnemonic": "mov", + "operands": "edi, 0xe" + }, + { + "address": "0x140011cf7", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, edi" + }, + { + "address": "0x140011cf9", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca20" + }, + { + "address": "0x140011cfe", + "size": 5, + "mnemonic": "and", + "operands": "dword ptr [rsp + 0x60], 0" + }, + { + "address": "0x140011d03", + "size": 7, + "mnemonic": "lea", + "operands": "rsi, [rip + 0x242f6]" + }, + { + "address": "0x140011d0a", + "size": 5, + "mnemonic": "mov", + "operands": "ebp, 0x100" + }, + { + "address": "0x140011d0f", + "size": 5, + "mnemonic": "lea", + "operands": "r9, [rsp + 0x60]" + }, + { + "address": "0x140011d14", + "size": 2, + "mnemonic": "mov", + "operands": "edx, ebp" + }, + { + "address": "0x140011d16", + "size": 4, + "mnemonic": "lea", + "operands": "r8d, [rdi - 0xa]" + }, + { + "address": "0x140011d1a", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x140011d1d", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xe48d]" + }, + { + "address": "0x140011d23", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x140011d25", + "size": 6, + "mnemonic": "je", + "operands": "0x140011dac" + } + ], + "successors": [ + "0x140011dac", + "0x140011d2b" + ] + } + ] + }, + { + "address": "0x140011bc8", + "name": "", + "blocks": [ + { + "address": "0x140011bc8", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140011bc8", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rip + 0x24439]" + }, + { + "address": "0x140011bcf", + "size": 4, + "mnemonic": "cmp", + "operands": "rcx, -1" + }, + { + "address": "0x140011bd3", + "size": 2, + "mnemonic": "jne", + "operands": "0x140011bd8" + }, + { + "address": "0x140011bd5", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140011bd7", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000cb08", + "name": "", + "blocks": [ + { + "address": "0x14000cb08", + "size": 21, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000cb08", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rbx" + }, + { + "address": "0x14000cb0d", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rsi" + }, + { + "address": "0x14000cb12", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000cb13", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000cb14", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x14000cb16", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000cb18", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14000cb1a", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14000cb1d", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x14000cb21", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 8]" + }, + { + "address": "0x14000cb25", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000cb27", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x14000cb2a", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rax]" + }, + { + "address": "0x14000cb2d", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x14000cb30", + "size": 3, + "mnemonic": "mov", + "operands": "r14d, dword ptr [rax]" + }, + { + "address": "0x14000cb33", + "size": 3, + "mnemonic": "test", + "operands": "rsi, rsi" + }, + { + "address": "0x14000cb36", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000cb48" + }, + { + "address": "0x14000cb38", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, r14d" + }, + { + "address": "0x14000cb3b", + "size": 5, + "mnemonic": "call", + "operands": "0x14000f858" + }, + { + "address": "0x14000cb40", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rax" + }, + { + "address": "0x14000cb43", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000cbf5" + } + ], + "successors": [ + "0x14000cbf5" + ] + } + ] + }, + { + "address": "0x14001e2cc", + "name": "", + "blocks": [ + { + "address": "0x14001e2cc", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e2cc", + "size": 4, + "mnemonic": "movzx", + "operands": "r10d, dx" + }, + { + "address": "0x14001e2d0", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rcx" + }, + { + "address": "0x14001e2d3", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x14001e2d6", + "size": 5, + "mnemonic": "movd", + "operands": "xmm0, r10d" + }, + { + "address": "0x14001e2db", + "size": 5, + "mnemonic": "pshuflw", + "operands": "xmm1, xmm0, 0" + }, + { + "address": "0x14001e2e0", + "size": 5, + "mnemonic": "pshufd", + "operands": "xmm2, xmm1, 0" + }, + { + "address": "0x14001e2e5", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r8" + }, + { + "address": "0x14001e2e8", + "size": 5, + "mnemonic": "and", + "operands": "eax, 0xfff" + }, + { + "address": "0x14001e2ed", + "size": 6, + "mnemonic": "cmp", + "operands": "rax, 0xff0" + }, + { + "address": "0x14001e2f3", + "size": 2, + "mnemonic": "ja", + "operands": "0x14001e317" + } + ], + "successors": [ + "0x14001e317", + "0x14001e2f5" + ] + }, + { + "address": "0x14001e317", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e317", + "size": 4, + "mnemonic": "cmp", + "operands": "word ptr [r8], dx" + }, + { + "address": "0x14001e31b", + "size": 2, + "mnemonic": "je", + "operands": "0x14001e344" + } + ], + "successors": [ + "0x14001e344", + "0x14001e31d" + ] + }, + { + "address": "0x14001e2f5", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e2f5", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmm0, xmmword ptr [r8]" + }, + { + "address": "0x14001e2fa", + "size": 3, + "mnemonic": "xorps", + "operands": "xmm1, xmm1" + }, + { + "address": "0x14001e2fd", + "size": 4, + "mnemonic": "pcmpeqw", + "operands": "xmm1, xmm0" + }, + { + "address": "0x14001e301", + "size": 4, + "mnemonic": "pcmpeqw", + "operands": "xmm0, xmm2" + }, + { + "address": "0x14001e305", + "size": 3, + "mnemonic": "orps", + "operands": "xmm1, xmm0" + }, + { + "address": "0x14001e308", + "size": 4, + "mnemonic": "pmovmskb", + "operands": "eax, xmm1" + }, + { + "address": "0x14001e30c", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001e30e", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001e32d" + }, + { + "address": "0x14001e310", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x10" + }, + { + "address": "0x14001e315", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001e328" + } + ], + "successors": [ + "0x14001e328" + ] + }, + { + "address": "0x14001e344", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001e344", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r8" + }, + { + "address": "0x14001e347", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001e31d", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e31d", + "size": 4, + "mnemonic": "cmp", + "operands": "word ptr [r8], r9w" + }, + { + "address": "0x14001e321", + "size": 2, + "mnemonic": "je", + "operands": "0x14001e341" + } + ], + "successors": [ + "0x14001e341", + "0x14001e323" + ] + }, + { + "address": "0x14001e328", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e328", + "size": 3, + "mnemonic": "add", + "operands": "r8, rax" + }, + { + "address": "0x14001e32b", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001e2e5" + } + ], + "successors": [ + "0x14001e2e5" + ] + }, + { + "address": "0x14001e341", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001e341", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001e343", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001e323", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e323", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 2" + }, + { + "address": "0x14001e328", + "size": 3, + "mnemonic": "add", + "operands": "r8, rax" + }, + { + "address": "0x14001e32b", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001e2e5" + } + ], + "successors": [ + "0x14001e2e5" + ] + }, + { + "address": "0x14001e2e5", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001e2e5", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r8" + }, + { + "address": "0x14001e2e8", + "size": 5, + "mnemonic": "and", + "operands": "eax, 0xfff" + }, + { + "address": "0x14001e2ed", + "size": 6, + "mnemonic": "cmp", + "operands": "rax, 0xff0" + }, + { + "address": "0x14001e2f3", + "size": 2, + "mnemonic": "ja", + "operands": "0x14001e317" + } + ], + "successors": [ + "0x14001e317", + "0x14001e2f5" + ] + } + ] + }, + { + "address": "0x14001053c", + "name": "", + "blocks": [ + { + "address": "0x14001053c", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001053c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140010541", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x140010546", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rdi" + }, + { + "address": "0x14001054b", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14001054d", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140010551", + "size": 2, + "mnemonic": "xor", + "operands": "ebx, ebx" + }, + { + "address": "0x140010553", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x140010556", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rcx" + }, + { + "address": "0x140010559", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14001055c", + "size": 2, + "mnemonic": "je", + "operands": "0x140010589" + } + ], + "successors": [ + "0x140010589", + "0x14001055e" + ] + }, + { + "address": "0x140010589", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140010589", + "size": 2, + "mnemonic": "mov", + "operands": "al, 1" + }, + { + "address": "0x14001058b", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140010590", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140010595", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14001059a", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001059e", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x1400105a0", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001055e", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001055e", + "size": 5, + "mnemonic": "movzx", + "operands": "esi, word ptr [r14 + rbx*2]" + }, + { + "address": "0x140010563", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cdf4" + }, + { + "address": "0x140010568", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rax" + }, + { + "address": "0x14001056b", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0xff" + }, + { + "address": "0x140010570", + "size": 3, + "mnemonic": "cmp", + "operands": "si, ax" + }, + { + "address": "0x140010573", + "size": 2, + "mnemonic": "ja", + "operands": "0x1400105a1" + } + ], + "successors": [ + "0x1400105a1", + "0x140010575" + ] + }, + { + "address": "0x1400105a1", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400105a1", + "size": 2, + "mnemonic": "xor", + "operands": "al, al" + }, + { + "address": "0x1400105a3", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001058b" + } + ], + "successors": [ + "0x14001058b" + ] + }, + { + "address": "0x140010575", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010575", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, word ptr [rdx + rsi*2]" + }, + { + "address": "0x140010579", + "size": 6, + "mnemonic": "test", + "operands": "ecx, 0x103" + }, + { + "address": "0x14001057f", + "size": 2, + "mnemonic": "je", + "operands": "0x1400105a1" + } + ], + "successors": [ + "0x1400105a1", + "0x140010581" + ] + }, + { + "address": "0x14001058b", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001058b", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140010590", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140010595", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14001059a", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001059e", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x1400105a0", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140010581", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010581", + "size": 3, + "mnemonic": "inc", + "operands": "rbx" + }, + { + "address": "0x140010584", + "size": 3, + "mnemonic": "cmp", + "operands": "rbx, rdi" + }, + { + "address": "0x140010587", + "size": 2, + "mnemonic": "jb", + "operands": "0x14001055e" + } + ], + "successors": [ + "0x14001055e", + "0x140010589" + ] + } + ] + }, + { + "address": "0x14001a3c0", + "name": "", + "blocks": [ + { + "address": "0x14001a3c0", + "size": 17, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001a3c0", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14001a3c5", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001a3c6", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001a3ca", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r9" + }, + { + "address": "0x14001a3cd", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x14001a3d0", + "size": 3, + "mnemonic": "mov", + "operands": "r11, rcx" + }, + { + "address": "0x14001a3d3", + "size": 3, + "mnemonic": "test", + "operands": "r9, r9" + }, + { + "address": "0x14001a3d6", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001a3f0" + }, + { + "address": "0x14001a3d8", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001a3db", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001a3f5" + }, + { + "address": "0x14001a3dd", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14001a3e0", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001a40b" + }, + { + "address": "0x14001a3e2", + "size": 3, + "mnemonic": "mov", + "operands": "eax, r9d" + }, + { + "address": "0x14001a3e5", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001a3ea", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001a3ee", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001a3ef", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000cdf4", + "name": "", + "blocks": [ + { + "address": "0x14000cdf4", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000cdf4", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000cdf8", + "size": 5, + "mnemonic": "call", + "operands": "0x1400118c4" + }, + { + "address": "0x14000cdfd", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x30]" + }, + { + "address": "0x14000ce02", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax + 0x90]" + }, + { + "address": "0x14000ce09", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rcx" + }, + { + "address": "0x14000ce0e", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x14000ce11", + "size": 5, + "mnemonic": "call", + "operands": "0x140015b2c" + }, + { + "address": "0x14000ce16", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000ce1b", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax]" + }, + { + "address": "0x14000ce1e", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000ce22", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001066c", + "name": "", + "blocks": [ + { + "address": "0x14001066c", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001066c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140010671", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x140010676", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x14001067b", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001067c", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14001067e", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140010680", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140010684", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x140010687", + "size": 2, + "mnemonic": "xor", + "operands": "ebp, ebp" + }, + { + "address": "0x140010689", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rcx" + }, + { + "address": "0x14001068c", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rax]" + }, + { + "address": "0x14001068f", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x140010692", + "size": 6, + "mnemonic": "je", + "operands": "0x1400107fe" + } + ], + "successors": [ + "0x1400107fe", + "0x140010698" + ] + }, + { + "address": "0x1400107fe", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400107fe", + "size": 3, + "mnemonic": "or", + "operands": "eax, 0xffffffff" + }, + { + "address": "0x140010801", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140010806", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14001080b", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x140010810", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140010814", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140010816", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140010818", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140010819", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140010698", + "size": 25, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010698", + "size": 7, + "mnemonic": "mov", + "operands": "r10, qword ptr [rip + 0x209a1]" + }, + { + "address": "0x14001069f", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, r10d" + }, + { + "address": "0x1400106a2", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, r10" + }, + { + "address": "0x1400106a5", + "size": 3, + "mnemonic": "xor", + "operands": "rsi, qword ptr [rdx]" + }, + { + "address": "0x1400106a8", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0x3f" + }, + { + "address": "0x1400106ab", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r10" + }, + { + "address": "0x1400106ae", + "size": 3, + "mnemonic": "ror", + "operands": "rsi, cl" + }, + { + "address": "0x1400106b1", + "size": 4, + "mnemonic": "xor", + "operands": "r9, qword ptr [rdx + 8]" + }, + { + "address": "0x1400106b5", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r10" + }, + { + "address": "0x1400106b8", + "size": 4, + "mnemonic": "xor", + "operands": "rbx, qword ptr [rdx + 0x10]" + }, + { + "address": "0x1400106bc", + "size": 3, + "mnemonic": "ror", + "operands": "r9, cl" + }, + { + "address": "0x1400106bf", + "size": 3, + "mnemonic": "ror", + "operands": "rbx, cl" + }, + { + "address": "0x1400106c2", + "size": 3, + "mnemonic": "cmp", + "operands": "r9, rbx" + }, + { + "address": "0x1400106c5", + "size": 6, + "mnemonic": "jne", + "operands": "0x140010772" + }, + { + "address": "0x1400106cb", + "size": 3, + "mnemonic": "sub", + "operands": "rbx, rsi" + }, + { + "address": "0x1400106ce", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x200" + }, + { + "address": "0x1400106d3", + "size": 4, + "mnemonic": "sar", + "operands": "rbx, 3" + }, + { + "address": "0x1400106d7", + "size": 3, + "mnemonic": "cmp", + "operands": "rbx, rax" + }, + { + "address": "0x1400106da", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rbx" + }, + { + "address": "0x1400106dd", + "size": 4, + "mnemonic": "cmova", + "operands": "rdi, rax" + }, + { + "address": "0x1400106e1", + "size": 3, + "mnemonic": "lea", + "operands": "eax, [rbp + 0x20]" + }, + { + "address": "0x1400106e4", + "size": 3, + "mnemonic": "add", + "operands": "rdi, rbx" + }, + { + "address": "0x1400106e7", + "size": 4, + "mnemonic": "cmove", + "operands": "rdi, rax" + }, + { + "address": "0x1400106eb", + "size": 3, + "mnemonic": "cmp", + "operands": "rdi, rbx" + }, + { + "address": "0x1400106ee", + "size": 2, + "mnemonic": "jb", + "operands": "0x14001070e" + } + ], + "successors": [ + "0x14001070e", + "0x1400106f0" + ] + }, + { + "address": "0x14001070e", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001070e", + "size": 4, + "mnemonic": "lea", + "operands": "rdi, [rbx + 4]" + }, + { + "address": "0x140010712", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 8" + }, + { + "address": "0x140010718", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rdi" + }, + { + "address": "0x14001071b", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x14001071e", + "size": 5, + "mnemonic": "call", + "operands": "0x14001be60" + }, + { + "address": "0x140010723", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x140010725", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rax" + }, + { + "address": "0x140010728", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001072d", + "size": 3, + "mnemonic": "test", + "operands": "r14, r14" + }, + { + "address": "0x140010730", + "size": 6, + "mnemonic": "je", + "operands": "0x1400107fe" + } + ], + "successors": [ + "0x1400107fe", + "0x140010736" + ] + }, + { + "address": "0x1400106f0", + "size": 19, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400106f0", + "size": 4, + "mnemonic": "lea", + "operands": "r8d, [rbp + 8]" + }, + { + "address": "0x1400106f4", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rdi" + }, + { + "address": "0x1400106f7", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x1400106fa", + "size": 5, + "mnemonic": "call", + "operands": "0x14001be60" + }, + { + "address": "0x1400106ff", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x140010701", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rax" + }, + { + "address": "0x140010704", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140010709", + "size": 3, + "mnemonic": "test", + "operands": "r14, r14" + }, + { + "address": "0x14001070c", + "size": 2, + "mnemonic": "jne", + "operands": "0x140010736" + }, + { + "address": "0x14001070e", + "size": 4, + "mnemonic": "lea", + "operands": "rdi, [rbx + 4]" + }, + { + "address": "0x140010712", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 8" + }, + { + "address": "0x140010718", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rdi" + }, + { + "address": "0x14001071b", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x14001071e", + "size": 5, + "mnemonic": "call", + "operands": "0x14001be60" + }, + { + "address": "0x140010723", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x140010725", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rax" + }, + { + "address": "0x140010728", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001072d", + "size": 3, + "mnemonic": "test", + "operands": "r14, r14" + }, + { + "address": "0x140010730", + "size": 6, + "mnemonic": "je", + "operands": "0x1400107fe" + } + ], + "successors": [ + "0x1400107fe", + "0x140010736" + ] + }, + { + "address": "0x140010736", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010736", + "size": 7, + "mnemonic": "mov", + "operands": "r10, qword ptr [rip + 0x20903]" + }, + { + "address": "0x14001073d", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [r14 + rbx*8]" + }, + { + "address": "0x140010741", + "size": 4, + "mnemonic": "lea", + "operands": "rbx, [r14 + rdi*8]" + }, + { + "address": "0x140010745", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, r14" + }, + { + "address": "0x140010748", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x14001074b", + "size": 3, + "mnemonic": "sub", + "operands": "rcx, r9" + }, + { + "address": "0x14001074e", + "size": 4, + "mnemonic": "add", + "operands": "rcx, 7" + }, + { + "address": "0x140010752", + "size": 4, + "mnemonic": "shr", + "operands": "rcx, 3" + }, + { + "address": "0x140010756", + "size": 3, + "mnemonic": "cmp", + "operands": "r9, rbx" + }, + { + "address": "0x140010759", + "size": 4, + "mnemonic": "cmova", + "operands": "rcx, rbp" + }, + { + "address": "0x14001075d", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140010760", + "size": 2, + "mnemonic": "je", + "operands": "0x140010772" + } + ], + "successors": [ + "0x140010772", + "0x140010762" + ] + }, + { + "address": "0x140010772", + "size": 43, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010772", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x40" + }, + { + "address": "0x140010778", + "size": 4, + "mnemonic": "lea", + "operands": "rdi, [r9 + 8]" + }, + { + "address": "0x14001077c", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, r8d" + }, + { + "address": "0x14001077f", + "size": 3, + "mnemonic": "mov", + "operands": "eax, r10d" + }, + { + "address": "0x140010782", + "size": 3, + "mnemonic": "and", + "operands": "eax, 0x3f" + }, + { + "address": "0x140010785", + "size": 2, + "mnemonic": "sub", + "operands": "ecx, eax" + }, + { + "address": "0x140010787", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [r15 + 8]" + }, + { + "address": "0x14001078b", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rax]" + }, + { + "address": "0x14001078e", + "size": 3, + "mnemonic": "ror", + "operands": "rdx, cl" + }, + { + "address": "0x140010791", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, r8d" + }, + { + "address": "0x140010794", + "size": 3, + "mnemonic": "xor", + "operands": "rdx, r10" + }, + { + "address": "0x140010797", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [r9], rdx" + }, + { + "address": "0x14001079a", + "size": 7, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rip + 0x2089f]" + }, + { + "address": "0x1400107a1", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edx" + }, + { + "address": "0x1400107a3", + "size": 3, + "mnemonic": "and", + "operands": "eax, 0x3f" + }, + { + "address": "0x1400107a6", + "size": 2, + "mnemonic": "sub", + "operands": "ecx, eax" + }, + { + "address": "0x1400107a8", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [r15]" + }, + { + "address": "0x1400107ab", + "size": 3, + "mnemonic": "ror", + "operands": "rsi, cl" + }, + { + "address": "0x1400107ae", + "size": 3, + "mnemonic": "xor", + "operands": "rsi, rdx" + }, + { + "address": "0x1400107b1", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax]" + }, + { + "address": "0x1400107b4", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rcx], rsi" + }, + { + "address": "0x1400107b7", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, r8d" + }, + { + "address": "0x1400107ba", + "size": 7, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rip + 0x2087f]" + }, + { + "address": "0x1400107c1", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edx" + }, + { + "address": "0x1400107c3", + "size": 3, + "mnemonic": "and", + "operands": "eax, 0x3f" + }, + { + "address": "0x1400107c6", + "size": 2, + "mnemonic": "sub", + "operands": "ecx, eax" + }, + { + "address": "0x1400107c8", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [r15]" + }, + { + "address": "0x1400107cb", + "size": 3, + "mnemonic": "ror", + "operands": "rdi, cl" + }, + { + "address": "0x1400107ce", + "size": 3, + "mnemonic": "xor", + "operands": "rdi, rdx" + }, + { + "address": "0x1400107d1", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rax]" + }, + { + "address": "0x1400107d4", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rdx + 8], rdi" + }, + { + "address": "0x1400107d8", + "size": 7, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rip + 0x20861]" + }, + { + "address": "0x1400107df", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edx" + }, + { + "address": "0x1400107e1", + "size": 3, + "mnemonic": "and", + "operands": "eax, 0x3f" + }, + { + "address": "0x1400107e4", + "size": 3, + "mnemonic": "sub", + "operands": "r8d, eax" + }, + { + "address": "0x1400107e7", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [r15]" + }, + { + "address": "0x1400107ea", + "size": 3, + "mnemonic": "mov", + "operands": "cl, r8b" + }, + { + "address": "0x1400107ed", + "size": 3, + "mnemonic": "ror", + "operands": "rbx, cl" + }, + { + "address": "0x1400107f0", + "size": 3, + "mnemonic": "xor", + "operands": "rbx, rdx" + }, + { + "address": "0x1400107f3", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax]" + }, + { + "address": "0x1400107f6", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x1400107f8", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 0x10], rbx" + }, + { + "address": "0x1400107fc", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140010801" + } + ], + "successors": [ + "0x140010801" + ] + }, + { + "address": "0x140010762", + "size": 47, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140010762", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r10" + }, + { + "address": "0x140010765", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r9" + }, + { + "address": "0x140010768", + "size": 3, + "mnemonic": "rep stosq", + "operands": "qword ptr [rdi], rax" + }, + { + "address": "0x14001076b", + "size": 7, + "mnemonic": "mov", + "operands": "r10, qword ptr [rip + 0x208ce]" + }, + { + "address": "0x140010772", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x40" + }, + { + "address": "0x140010778", + "size": 4, + "mnemonic": "lea", + "operands": "rdi, [r9 + 8]" + }, + { + "address": "0x14001077c", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, r8d" + }, + { + "address": "0x14001077f", + "size": 3, + "mnemonic": "mov", + "operands": "eax, r10d" + }, + { + "address": "0x140010782", + "size": 3, + "mnemonic": "and", + "operands": "eax, 0x3f" + }, + { + "address": "0x140010785", + "size": 2, + "mnemonic": "sub", + "operands": "ecx, eax" + }, + { + "address": "0x140010787", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [r15 + 8]" + }, + { + "address": "0x14001078b", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rax]" + }, + { + "address": "0x14001078e", + "size": 3, + "mnemonic": "ror", + "operands": "rdx, cl" + }, + { + "address": "0x140010791", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, r8d" + }, + { + "address": "0x140010794", + "size": 3, + "mnemonic": "xor", + "operands": "rdx, r10" + }, + { + "address": "0x140010797", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [r9], rdx" + }, + { + "address": "0x14001079a", + "size": 7, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rip + 0x2089f]" + }, + { + "address": "0x1400107a1", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edx" + }, + { + "address": "0x1400107a3", + "size": 3, + "mnemonic": "and", + "operands": "eax, 0x3f" + }, + { + "address": "0x1400107a6", + "size": 2, + "mnemonic": "sub", + "operands": "ecx, eax" + }, + { + "address": "0x1400107a8", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [r15]" + }, + { + "address": "0x1400107ab", + "size": 3, + "mnemonic": "ror", + "operands": "rsi, cl" + }, + { + "address": "0x1400107ae", + "size": 3, + "mnemonic": "xor", + "operands": "rsi, rdx" + }, + { + "address": "0x1400107b1", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax]" + }, + { + "address": "0x1400107b4", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rcx], rsi" + }, + { + "address": "0x1400107b7", + "size": 3, + "mnemonic": "mov", + "operands": "ecx, r8d" + }, + { + "address": "0x1400107ba", + "size": 7, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rip + 0x2087f]" + }, + { + "address": "0x1400107c1", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edx" + }, + { + "address": "0x1400107c3", + "size": 3, + "mnemonic": "and", + "operands": "eax, 0x3f" + }, + { + "address": "0x1400107c6", + "size": 2, + "mnemonic": "sub", + "operands": "ecx, eax" + }, + { + "address": "0x1400107c8", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [r15]" + }, + { + "address": "0x1400107cb", + "size": 3, + "mnemonic": "ror", + "operands": "rdi, cl" + }, + { + "address": "0x1400107ce", + "size": 3, + "mnemonic": "xor", + "operands": "rdi, rdx" + }, + { + "address": "0x1400107d1", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rax]" + }, + { + "address": "0x1400107d4", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rdx + 8], rdi" + }, + { + "address": "0x1400107d8", + "size": 7, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rip + 0x20861]" + }, + { + "address": "0x1400107df", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edx" + }, + { + "address": "0x1400107e1", + "size": 3, + "mnemonic": "and", + "operands": "eax, 0x3f" + }, + { + "address": "0x1400107e4", + "size": 3, + "mnemonic": "sub", + "operands": "r8d, eax" + }, + { + "address": "0x1400107e7", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [r15]" + }, + { + "address": "0x1400107ea", + "size": 3, + "mnemonic": "mov", + "operands": "cl, r8b" + }, + { + "address": "0x1400107ed", + "size": 3, + "mnemonic": "ror", + "operands": "rbx, cl" + }, + { + "address": "0x1400107f0", + "size": 3, + "mnemonic": "xor", + "operands": "rbx, rdx" + }, + { + "address": "0x1400107f3", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax]" + }, + { + "address": "0x1400107f6", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x1400107f8", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 0x10], rbx" + }, + { + "address": "0x1400107fc", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140010801" + } + ], + "successors": [ + "0x140010801" + ] + }, + { + "address": "0x140010801", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140010801", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x140010806", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14001080b", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x140010810", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140010814", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140010816", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140010818", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140010819", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001185c", + "name": "", + "blocks": [ + { + "address": "0x14001185c", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001185c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140011861", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140011862", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140011866", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x140011869", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdx" + }, + { + "address": "0x14001186c", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x90]" + }, + { + "address": "0x140011873", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140011876", + "size": 2, + "mnemonic": "je", + "operands": "0x1400118a4" + } + ], + "successors": [ + "0x1400118a4", + "0x140011878" + ] + }, + { + "address": "0x1400118a4", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400118a4", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rdi + 0x90], rbx" + }, + { + "address": "0x1400118ab", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x1400118ae", + "size": 2, + "mnemonic": "je", + "operands": "0x1400118b8" + } + ], + "successors": [ + "0x1400118b8", + "0x1400118b0" + ] + }, + { + "address": "0x140011878", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011878", + "size": 5, + "mnemonic": "call", + "operands": "0x14001a844" + }, + { + "address": "0x14001187d", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdi + 0x90]" + }, + { + "address": "0x140011884", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x219ad]" + }, + { + "address": "0x14001188b", + "size": 2, + "mnemonic": "je", + "operands": "0x1400118a4" + } + ], + "successors": [ + "0x1400118a4", + "0x14001188d" + ] + }, + { + "address": "0x1400118b8", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400118b8", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x1400118bd", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400118c1", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400118c2", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400118b0", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400118b0", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x1400118b3", + "size": 5, + "mnemonic": "call", + "operands": "0x14001a5b8" + }, + { + "address": "0x1400118b8", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x1400118bd", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400118c1", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400118c2", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001188d", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001188d", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1fa3c]" + }, + { + "address": "0x140011894", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, rax" + }, + { + "address": "0x140011897", + "size": 2, + "mnemonic": "je", + "operands": "0x1400118a4" + } + ], + "successors": [ + "0x1400118a4", + "0x140011899" + ] + }, + { + "address": "0x140011899", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011899", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rcx + 0x10], 0" + }, + { + "address": "0x14001189d", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400118a4" + }, + { + "address": "0x14001189f", + "size": 5, + "mnemonic": "call", + "operands": "0x14001a644" + }, + { + "address": "0x1400118a4", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rdi + 0x90], rbx" + }, + { + "address": "0x1400118ab", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x1400118ae", + "size": 2, + "mnemonic": "je", + "operands": "0x1400118b8" + } + ], + "successors": [ + "0x1400118b8", + "0x1400118b0" + ] + } + ] + }, + { + "address": "0x140015b60", + "name": "", + "blocks": [ + { + "address": "0x140015b60", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015b60", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140015b62", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140015b66", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1d6cb]" + }, + { + "address": "0x140015b6d", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdx" + }, + { + "address": "0x140015b70", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax + r8*8]" + }, + { + "address": "0x140015b74", + "size": 3, + "mnemonic": "cmp", + "operands": "qword ptr [rdx], rax" + }, + { + "address": "0x140015b77", + "size": 2, + "mnemonic": "je", + "operands": "0x140015b8f" + } + ], + "successors": [ + "0x140015b8f", + "0x140015b79" + ] + }, + { + "address": "0x140015b8f", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140015b8f", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140015b93", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140015b94", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140015b79", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140015b79", + "size": 6, + "mnemonic": "mov", + "operands": "eax, dword ptr [rcx + 0x3a8]" + }, + { + "address": "0x140015b7f", + "size": 6, + "mnemonic": "test", + "operands": "dword ptr [rip + 0x1ba0b], eax" + }, + { + "address": "0x140015b85", + "size": 2, + "mnemonic": "jne", + "operands": "0x140015b8f" + }, + { + "address": "0x140015b87", + "size": 5, + "mnemonic": "call", + "operands": "0x14001a8ec" + }, + { + "address": "0x140015b8c", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rbx], rax" + }, + { + "address": "0x140015b8f", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140015b93", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140015b94", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140015bcc", + "name": "", + "blocks": [ + { + "address": "0x140015bcc", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140015bcc", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140015bce", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140015bd2", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1dc67]" + }, + { + "address": "0x140015bd9", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdx" + }, + { + "address": "0x140015bdc", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax + r8*8]" + }, + { + "address": "0x140015be0", + "size": 3, + "mnemonic": "cmp", + "operands": "qword ptr [rdx], rax" + }, + { + "address": "0x140015be3", + "size": 2, + "mnemonic": "je", + "operands": "0x140015bfb" + } + ], + "successors": [ + "0x140015bfb", + "0x140015be5" + ] + }, + { + "address": "0x140015bfb", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140015bfb", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140015bff", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140015c00", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140015be5", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140015be5", + "size": 6, + "mnemonic": "mov", + "operands": "eax, dword ptr [rcx + 0x3a8]" + }, + { + "address": "0x140015beb", + "size": 6, + "mnemonic": "test", + "operands": "dword ptr [rip + 0x1b99f], eax" + }, + { + "address": "0x140015bf1", + "size": 2, + "mnemonic": "jne", + "operands": "0x140015bfb" + }, + { + "address": "0x140015bf3", + "size": 5, + "mnemonic": "call", + "operands": "0x1400188c8" + }, + { + "address": "0x140015bf8", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rbx], rax" + }, + { + "address": "0x140015bfb", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140015bff", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140015c00", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140016bc8", + "name": "", + "blocks": [ + { + "address": "0x140016bc8", + "size": 30, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016bc8", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140016bca", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140016bcb", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140016bcc", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140016bcd", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140016bcf", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140016bd1", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140016bd3", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x140016bd7", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x1a462]" + }, + { + "address": "0x140016bde", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x140016be1", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rax" + }, + { + "address": "0x140016be6", + "size": 8, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0xa0]" + }, + { + "address": "0x140016bee", + "size": 7, + "mnemonic": "lea", + "operands": "rbx, [rip + 0x1cb4b]" + }, + { + "address": "0x140016bf5", + "size": 3, + "mnemonic": "xor", + "operands": "r12d, r12d" + }, + { + "address": "0x140016bf8", + "size": 7, + "mnemonic": "lea", + "operands": "rdi, [rip + 0xa881]" + }, + { + "address": "0x140016bff", + "size": 3, + "mnemonic": "test", + "operands": "r9, r9" + }, + { + "address": "0x140016c02", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdx" + }, + { + "address": "0x140016c05", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rdx" + }, + { + "address": "0x140016c08", + "size": 4, + "mnemonic": "cmovne", + "operands": "rbx, r9" + }, + { + "address": "0x140016c0c", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x140016c0f", + "size": 5, + "mnemonic": "lea", + "operands": "ebp, [r12 + 1]" + }, + { + "address": "0x140016c14", + "size": 4, + "mnemonic": "cmovne", + "operands": "rbp, r8" + }, + { + "address": "0x140016c18", + "size": 4, + "mnemonic": "cmovne", + "operands": "rdi, rdx" + }, + { + "address": "0x140016c1c", + "size": 3, + "mnemonic": "neg", + "operands": "rax" + }, + { + "address": "0x140016c1f", + "size": 3, + "mnemonic": "sbb", + "operands": "r14, r14" + }, + { + "address": "0x140016c22", + "size": 3, + "mnemonic": "and", + "operands": "r14, rcx" + }, + { + "address": "0x140016c25", + "size": 3, + "mnemonic": "test", + "operands": "rbp, rbp" + }, + { + "address": "0x140016c28", + "size": 2, + "mnemonic": "jne", + "operands": "0x140016c36" + }, + { + "address": "0x140016c2a", + "size": 7, + "mnemonic": "mov", + "operands": "rax, 0xfffffffffffffffe" + }, + { + "address": "0x140016c31", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140016d69" + } + ], + "successors": [ + "0x140016d69" + ] + } + ] + }, + { + "address": "0x14001949c", + "name": "", + "blocks": [ + { + "address": "0x14001949c", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001949c", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400194a0", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, -2" + }, + { + "address": "0x1400194a3", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400194ba" + }, + { + "address": "0x1400194a5", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d854" + }, + { + "address": "0x1400194aa", + "size": 3, + "mnemonic": "and", + "operands": "dword ptr [rax], 0" + }, + { + "address": "0x1400194ad", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x1400194b2", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 9" + }, + { + "address": "0x1400194b8", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140019508" + } + ], + "successors": [ + "0x140019508" + ] + }, + { + "address": "0x140019508", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140019508", + "size": 4, + "mnemonic": "or", + "operands": "rax, 0xffffffffffffffff" + }, + { + "address": "0x14001950c", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x140019510", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400122e0", + "name": "", + "blocks": [ + { + "address": "0x1400122e0", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400122e0", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x1400122e5", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x1400122e6", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400122ea", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x23daf]" + }, + { + "address": "0x1400122f1", + "size": 2, + "mnemonic": "mov", + "operands": "edi, edx" + }, + { + "address": "0x1400122f3", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x1400122f6", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, -1" + }, + { + "address": "0x1400122fa", + "size": 2, + "mnemonic": "je", + "operands": "0x14001232f" + } + ], + "successors": [ + "0x14001232f", + "0x1400122fc" + ] + }, + { + "address": "0x14001232f", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001232f", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140012332", + "size": 5, + "mnemonic": "call", + "operands": "0x14001c11c" + }, + { + "address": "0x140012337", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001233c", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140012340", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140012341", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400122fc", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400122fc", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x1400122ff", + "size": 2, + "mnemonic": "jne", + "operands": "0x140012323" + }, + { + "address": "0x140012301", + "size": 7, + "mnemonic": "lea", + "operands": "r9, [rip + 0x146b8]" + }, + { + "address": "0x140012308", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip + 0x146a9]" + }, + { + "address": "0x14001230f", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x146aa]" + }, + { + "address": "0x140012316", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rax + 0x14]" + }, + { + "address": "0x140012319", + "size": 5, + "mnemonic": "call", + "operands": "0x140011c00" + }, + { + "address": "0x14001231e", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140012321", + "size": 2, + "mnemonic": "je", + "operands": "0x14001232f" + } + ], + "successors": [ + "0x14001232f", + "0x140012323" + ] + }, + { + "address": "0x140012323", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140012323", + "size": 2, + "mnemonic": "mov", + "operands": "edx, edi" + }, + { + "address": "0x140012325", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140012328", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3a0" + }, + { + "address": "0x14001232d", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140012337" + } + ], + "successors": [ + "0x140012337" + ] + }, + { + "address": "0x140012337", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140012337", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001233c", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140012340", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140012341", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400118e0", + "name": "", + "blocks": [ + { + "address": "0x1400118e0", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400118e0", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x38" + }, + { + "address": "0x1400118e4", + "size": 9, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], 0xfffffffffffffffe" + }, + { + "address": "0x1400118ed", + "size": 6, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rip + 0x1f9cd]" + }, + { + "address": "0x1400118f3", + "size": 3, + "mnemonic": "cmp", + "operands": "ecx, -1" + }, + { + "address": "0x1400118f6", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400118fc" + }, + { + "address": "0x1400118f8", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x1400118fa", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140011902" + } + ], + "successors": [ + "0x140011902" + ] + }, + { + "address": "0x140011902", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011902", + "size": 4, + "mnemonic": "cmp", + "operands": "rax, -1" + }, + { + "address": "0x140011906", + "size": 2, + "mnemonic": "je", + "operands": "0x14001191c" + } + ], + "successors": [ + "0x14001191c", + "0x140011908" + ] + }, + { + "address": "0x14001191c", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001191c", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140011921", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140011908", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011908", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001190b", + "size": 2, + "mnemonic": "jne", + "operands": "0x140011917" + }, + { + "address": "0x14001190d", + "size": 5, + "mnemonic": "call", + "operands": "0x1400117a4" + }, + { + "address": "0x140011912", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140011915", + "size": 2, + "mnemonic": "je", + "operands": "0x14001191c" + } + ], + "successors": [ + "0x14001191c", + "0x140011917" + ] + }, + { + "address": "0x140011917", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140011917", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x38" + }, + { + "address": "0x14001191b", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140018540", + "name": "", + "blocks": [ + { + "address": "0x140018540", + "size": 24, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140018540", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsp" + }, + { + "address": "0x140018543", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 8], rbx" + }, + { + "address": "0x140018547", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x10], rsi" + }, + { + "address": "0x14001854b", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x20], r9" + }, + { + "address": "0x14001854f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x18], r8" + }, + { + "address": "0x140018553", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x140018554", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140018555", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140018557", + "size": 7, + "mnemonic": "lea", + "operands": "rbp, [rax - 0x188]" + }, + { + "address": "0x14001855e", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x270" + }, + { + "address": "0x140018565", + "size": 3, + "mnemonic": "mov", + "operands": "r14b, dl" + }, + { + "address": "0x140018568", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, ecx" + }, + { + "address": "0x14001856a", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r9" + }, + { + "address": "0x14001856d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r8" + }, + { + "address": "0x140018570", + "size": 5, + "mnemonic": "call", + "operands": "0x1400187b0" + }, + { + "address": "0x140018575", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x140018577", + "size": 5, + "mnemonic": "call", + "operands": "0x140018230" + }, + { + "address": "0x14001857c", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbp + 0x1a0]" + }, + { + "address": "0x140018583", + "size": 2, + "mnemonic": "mov", + "operands": "edi, eax" + }, + { + "address": "0x140018585", + "size": 7, + "mnemonic": "mov", + "operands": "r8, qword ptr [rcx + 0x88]" + }, + { + "address": "0x14001858c", + "size": 4, + "mnemonic": "cmp", + "operands": "eax, dword ptr [r8 + 4]" + }, + { + "address": "0x140018590", + "size": 2, + "mnemonic": "jne", + "operands": "0x140018599" + }, + { + "address": "0x140018592", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140018594", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140018797" + } + ], + "successors": [ + "0x140018797" + ] + } + ] + }, + { + "address": "0x14000dca0", + "name": "", + "blocks": [ + { + "address": "0x14000dca0", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000dca0", + "size": 6, + "mnemonic": "mov", + "operands": "eax, dword ptr [rip + 0x233f2]" + }, + { + "address": "0x14000dca6", + "size": 3, + "mnemonic": "mov", + "operands": "r11, rdx" + }, + { + "address": "0x14000dca9", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rcx" + }, + { + "address": "0x14000dcac", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 5" + }, + { + "address": "0x14000dcaf", + "size": 6, + "mnemonic": "jl", + "operands": "0x14000dd94" + } + ], + "successors": [ + "0x14000dd94", + "0x14000dcb5" + ] + }, + { + "address": "0x14000dd94", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000dd94", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x14000dd97", + "size": 6, + "mnemonic": "jl", + "operands": "0x14000de7d" + } + ], + "successors": [ + "0x14000de7d", + "0x14000dd9d" + ] + }, + { + "address": "0x14000dcb5", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000dcb5", + "size": 4, + "mnemonic": "test", + "operands": "r9b, 1" + }, + { + "address": "0x14000dcb9", + "size": 2, + "mnemonic": "je", + "operands": "0x14000dced" + } + ], + "successors": [ + "0x14000dced", + "0x14000dcbb" + ] + }, + { + "address": "0x14000de7d", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000de7d", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rcx + rdx*2]" + }, + { + "address": "0x14000de81", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r9" + }, + { + "address": "0x14000de84", + "size": 3, + "mnemonic": "cmp", + "operands": "r9, rcx" + }, + { + "address": "0x14000de87", + "size": 2, + "mnemonic": "je", + "operands": "0x14000de9f" + } + ], + "successors": [ + "0x14000de9f", + "0x14000de89" + ] + }, + { + "address": "0x14000dd9d", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000dd9d", + "size": 4, + "mnemonic": "test", + "operands": "r9b, 1" + }, + { + "address": "0x14000dda1", + "size": 2, + "mnemonic": "je", + "operands": "0x14000ddcd" + } + ], + "successors": [ + "0x14000ddcd", + "0x14000dda3" + ] + }, + { + "address": "0x14000dced", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000dced", + "size": 3, + "mnemonic": "xor", + "operands": "r10d, r10d" + }, + { + "address": "0x14000dcf0", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0x1f" + }, + { + "address": "0x14000dcf3", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x20" + }, + { + "address": "0x14000dcf8", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r9" + }, + { + "address": "0x14000dcfb", + "size": 3, + "mnemonic": "sub", + "operands": "rax, rcx" + }, + { + "address": "0x14000dcfe", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14000dd01", + "size": 4, + "mnemonic": "cmovne", + "operands": "r10, rax" + }, + { + "address": "0x14000dd05", + "size": 3, + "mnemonic": "shr", + "operands": "r10, 1" + }, + { + "address": "0x14000dd08", + "size": 3, + "mnemonic": "cmp", + "operands": "r11, r10" + }, + { + "address": "0x14000dd0b", + "size": 4, + "mnemonic": "cmovb", + "operands": "r10, r11" + }, + { + "address": "0x14000dd0f", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r9 + r10*2]" + }, + { + "address": "0x14000dd13", + "size": 3, + "mnemonic": "cmp", + "operands": "r9, rax" + }, + { + "address": "0x14000dd16", + "size": 2, + "mnemonic": "je", + "operands": "0x14000dd27" + } + ], + "successors": [ + "0x14000dd27", + "0x14000dd18" + ] + }, + { + "address": "0x14000dcbb", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000dcbb", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rcx + rdx*2]" + }, + { + "address": "0x14000dcbf", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rcx" + }, + { + "address": "0x14000dcc2", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, rax" + }, + { + "address": "0x14000dcc5", + "size": 6, + "mnemonic": "je", + "operands": "0x14000dd8a" + } + ], + "successors": [ + "0x14000dd8a", + "0x14000dccb" + ] + }, + { + "address": "0x14000de9f", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000de9f", + "size": 3, + "mnemonic": "sub", + "operands": "rax, r9" + }, + { + "address": "0x14000dea2", + "size": 3, + "mnemonic": "sar", + "operands": "rax, 1" + }, + { + "address": "0x14000dea5", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000de89", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000de89", + "size": 7, + "mnemonic": "nop", + "operands": "dword ptr [rax]" + }, + { + "address": "0x14000de90", + "size": 4, + "mnemonic": "cmp", + "operands": "word ptr [rax], 0" + }, + { + "address": "0x14000de94", + "size": 2, + "mnemonic": "je", + "operands": "0x14000de9f" + } + ], + "successors": [ + "0x14000de9f", + "0x14000de96" + ] + }, + { + "address": "0x14000ddcd", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ddcd", + "size": 3, + "mnemonic": "xor", + "operands": "r10d, r10d" + }, + { + "address": "0x14000ddd0", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x14000ddd3", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x10" + }, + { + "address": "0x14000ddd8", + "size": 3, + "mnemonic": "sub", + "operands": "rax, rcx" + }, + { + "address": "0x14000dddb", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14000ddde", + "size": 4, + "mnemonic": "cmovne", + "operands": "r10, rax" + }, + { + "address": "0x14000dde2", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r9" + }, + { + "address": "0x14000dde5", + "size": 3, + "mnemonic": "shr", + "operands": "r10, 1" + }, + { + "address": "0x14000dde8", + "size": 3, + "mnemonic": "cmp", + "operands": "r11, r10" + }, + { + "address": "0x14000ddeb", + "size": 4, + "mnemonic": "cmovb", + "operands": "r10, r11" + }, + { + "address": "0x14000ddef", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [r9 + r10*2]" + }, + { + "address": "0x14000ddf3", + "size": 3, + "mnemonic": "cmp", + "operands": "r9, rcx" + }, + { + "address": "0x14000ddf6", + "size": 2, + "mnemonic": "je", + "operands": "0x14000de07" + } + ], + "successors": [ + "0x14000de07", + "0x14000ddf8" + ] + }, + { + "address": "0x14000dda3", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000dda3", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rcx + rdx*2]" + }, + { + "address": "0x14000dda7", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r9" + }, + { + "address": "0x14000ddaa", + "size": 3, + "mnemonic": "cmp", + "operands": "r9, rcx" + }, + { + "address": "0x14000ddad", + "size": 6, + "mnemonic": "je", + "operands": "0x14000de9f" + } + ], + "successors": [ + "0x14000de9f", + "0x14000ddb3" + ] + }, + { + "address": "0x14000dd27", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000dd27", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x14000dd2a", + "size": 3, + "mnemonic": "sar", + "operands": "rdx, 1" + }, + { + "address": "0x14000dd2d", + "size": 3, + "mnemonic": "cmp", + "operands": "rdx, r10" + }, + { + "address": "0x14000dd30", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000dd90" + }, + { + "address": "0x14000dd32", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [r9 + rdx*2]" + }, + { + "address": "0x14000dd36", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r11" + }, + { + "address": "0x14000dd39", + "size": 3, + "mnemonic": "sub", + "operands": "rcx, r10" + }, + { + "address": "0x14000dd3c", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rcx" + }, + { + "address": "0x14000dd3f", + "size": 3, + "mnemonic": "and", + "operands": "eax, 0x1f" + }, + { + "address": "0x14000dd42", + "size": 3, + "mnemonic": "sub", + "operands": "rcx, rax" + }, + { + "address": "0x14000dd45", + "size": 3, + "mnemonic": "add", + "operands": "rcx, rdx" + }, + { + "address": "0x14000dd48", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [r9 + rcx*2]" + }, + { + "address": "0x14000dd4c", + "size": 3, + "mnemonic": "cmp", + "operands": "r8, rdx" + }, + { + "address": "0x14000dd4f", + "size": 2, + "mnemonic": "je", + "operands": "0x14000dd6e" + } + ], + "successors": [ + "0x14000dd6e", + "0x14000dd51" + ] + }, + { + "address": "0x14000dd18", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000dd18", + "size": 4, + "mnemonic": "cmp", + "operands": "word ptr [rdx], 0" + }, + { + "address": "0x14000dd1c", + "size": 2, + "mnemonic": "je", + "operands": "0x14000dd27" + } + ], + "successors": [ + "0x14000dd27", + "0x14000dd1e" + ] + }, + { + "address": "0x14000dd8a", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000dd8a", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x14000dd8d", + "size": 3, + "mnemonic": "sar", + "operands": "rdx, 1" + }, + { + "address": "0x14000dd90", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdx" + }, + { + "address": "0x14000dd93", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000dccb", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000dccb", + "size": 5, + "mnemonic": "nop", + "operands": "dword ptr [rax + rax]" + }, + { + "address": "0x14000dcd0", + "size": 4, + "mnemonic": "cmp", + "operands": "word ptr [rdx], 0" + }, + { + "address": "0x14000dcd4", + "size": 6, + "mnemonic": "je", + "operands": "0x14000dd8a" + } + ], + "successors": [ + "0x14000dd8a", + "0x14000dcda" + ] + }, + { + "address": "0x14000de96", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000de96", + "size": 4, + "mnemonic": "add", + "operands": "rax, 2" + }, + { + "address": "0x14000de9a", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, rcx" + }, + { + "address": "0x14000de9d", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000de90" + }, + { + "address": "0x14000de9f", + "size": 3, + "mnemonic": "sub", + "operands": "rax, r9" + }, + { + "address": "0x14000dea2", + "size": 3, + "mnemonic": "sar", + "operands": "rax, 1" + }, + { + "address": "0x14000dea5", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000de07", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000de07", + "size": 3, + "mnemonic": "sub", + "operands": "rax, r9" + }, + { + "address": "0x14000de0a", + "size": 3, + "mnemonic": "sar", + "operands": "rax, 1" + }, + { + "address": "0x14000de0d", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, r10" + }, + { + "address": "0x14000de10", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000dea5" + }, + { + "address": "0x14000de16", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r10" + }, + { + "address": "0x14000de19", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [r9 + rax*2]" + }, + { + "address": "0x14000de1d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdx" + }, + { + "address": "0x14000de20", + "size": 3, + "mnemonic": "xorps", + "operands": "xmm1, xmm1" + }, + { + "address": "0x14000de23", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x14000de26", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, rcx" + }, + { + "address": "0x14000de29", + "size": 3, + "mnemonic": "add", + "operands": "rdx, rax" + }, + { + "address": "0x14000de2c", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [r9 + rdx*2]" + }, + { + "address": "0x14000de30", + "size": 3, + "mnemonic": "cmp", + "operands": "r8, rcx" + }, + { + "address": "0x14000de33", + "size": 2, + "mnemonic": "je", + "operands": "0x14000de5a" + } + ], + "successors": [ + "0x14000de5a", + "0x14000de35" + ] + }, + { + "address": "0x14000ddf8", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ddf8", + "size": 4, + "mnemonic": "cmp", + "operands": "word ptr [rax], 0" + }, + { + "address": "0x14000ddfc", + "size": 2, + "mnemonic": "je", + "operands": "0x14000de07" + } + ], + "successors": [ + "0x14000de07", + "0x14000ddfe" + ] + }, + { + "address": "0x14000ddb3", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ddb3", + "size": 4, + "mnemonic": "cmp", + "operands": "word ptr [rax], 0" + }, + { + "address": "0x14000ddb7", + "size": 6, + "mnemonic": "je", + "operands": "0x14000de9f" + } + ], + "successors": [ + "0x14000de9f", + "0x14000ddbd" + ] + }, + { + "address": "0x14000dd6e", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000dd6e", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r9 + r11*2]" + }, + { + "address": "0x14000dd72", + "size": 3, + "mnemonic": "cmp", + "operands": "r8, rax" + }, + { + "address": "0x14000dd75", + "size": 2, + "mnemonic": "je", + "operands": "0x14000dd87" + } + ], + "successors": [ + "0x14000dd87", + "0x14000dd77" + ] + }, + { + "address": "0x14000dd51", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000dd51", + "size": 4, + "mnemonic": "vpxor", + "operands": "xmm1, xmm1, xmm1" + }, + { + "address": "0x14000dd55", + "size": 5, + "mnemonic": "vpcmpeqw", + "operands": "ymm1, ymm1, ymmword ptr [r8]" + }, + { + "address": "0x14000dd5a", + "size": 4, + "mnemonic": "vpmovmskb", + "operands": "eax, ymm1" + }, + { + "address": "0x14000dd5e", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000dd60", + "size": 3, + "mnemonic": "vzeroupper", + "operands": "" + }, + { + "address": "0x14000dd63", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000dd6e" + }, + { + "address": "0x14000dd65", + "size": 4, + "mnemonic": "add", + "operands": "r8, 0x20" + }, + { + "address": "0x14000dd69", + "size": 3, + "mnemonic": "cmp", + "operands": "r8, rdx" + }, + { + "address": "0x14000dd6c", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000dd51" + }, + { + "address": "0x14000dd6e", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r9 + r11*2]" + }, + { + "address": "0x14000dd72", + "size": 3, + "mnemonic": "cmp", + "operands": "r8, rax" + }, + { + "address": "0x14000dd75", + "size": 2, + "mnemonic": "je", + "operands": "0x14000dd87" + } + ], + "successors": [ + "0x14000dd87", + "0x14000dd77" + ] + }, + { + "address": "0x14000dd1e", + "size": 17, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000dd1e", + "size": 4, + "mnemonic": "add", + "operands": "rdx, 2" + }, + { + "address": "0x14000dd22", + "size": 3, + "mnemonic": "cmp", + "operands": "rdx, rax" + }, + { + "address": "0x14000dd25", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000dd18" + }, + { + "address": "0x14000dd27", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x14000dd2a", + "size": 3, + "mnemonic": "sar", + "operands": "rdx, 1" + }, + { + "address": "0x14000dd2d", + "size": 3, + "mnemonic": "cmp", + "operands": "rdx, r10" + }, + { + "address": "0x14000dd30", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000dd90" + }, + { + "address": "0x14000dd32", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [r9 + rdx*2]" + }, + { + "address": "0x14000dd36", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r11" + }, + { + "address": "0x14000dd39", + "size": 3, + "mnemonic": "sub", + "operands": "rcx, r10" + }, + { + "address": "0x14000dd3c", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rcx" + }, + { + "address": "0x14000dd3f", + "size": 3, + "mnemonic": "and", + "operands": "eax, 0x1f" + }, + { + "address": "0x14000dd42", + "size": 3, + "mnemonic": "sub", + "operands": "rcx, rax" + }, + { + "address": "0x14000dd45", + "size": 3, + "mnemonic": "add", + "operands": "rcx, rdx" + }, + { + "address": "0x14000dd48", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [r9 + rcx*2]" + }, + { + "address": "0x14000dd4c", + "size": 3, + "mnemonic": "cmp", + "operands": "r8, rdx" + }, + { + "address": "0x14000dd4f", + "size": 2, + "mnemonic": "je", + "operands": "0x14000dd6e" + } + ], + "successors": [ + "0x14000dd6e", + "0x14000dd51" + ] + }, + { + "address": "0x14000dcda", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000dcda", + "size": 4, + "mnemonic": "add", + "operands": "rdx, 2" + }, + { + "address": "0x14000dcde", + "size": 3, + "mnemonic": "cmp", + "operands": "rdx, rax" + }, + { + "address": "0x14000dce1", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000dcd0" + }, + { + "address": "0x14000dce3", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x14000dce6", + "size": 3, + "mnemonic": "sar", + "operands": "rdx, 1" + }, + { + "address": "0x14000dce9", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdx" + }, + { + "address": "0x14000dcec", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000de5a", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000de5a", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r9 + r11*2]" + }, + { + "address": "0x14000de5e", + "size": 3, + "mnemonic": "cmp", + "operands": "r8, rax" + }, + { + "address": "0x14000de61", + "size": 2, + "mnemonic": "je", + "operands": "0x14000de73" + } + ], + "successors": [ + "0x14000de73", + "0x14000de63" + ] + }, + { + "address": "0x14000de35", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000de35", + "size": 11, + "mnemonic": "nop", + "operands": "word ptr [rax + rax]" + }, + { + "address": "0x14000de40", + "size": 4, + "mnemonic": "movdqa", + "operands": "xmm0, xmm1" + }, + { + "address": "0x14000de44", + "size": 5, + "mnemonic": "pcmpeqw", + "operands": "xmm0, xmmword ptr [r8]" + }, + { + "address": "0x14000de49", + "size": 4, + "mnemonic": "pmovmskb", + "operands": "eax, xmm0" + }, + { + "address": "0x14000de4d", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000de4f", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000de5a" + }, + { + "address": "0x14000de51", + "size": 4, + "mnemonic": "add", + "operands": "r8, 0x10" + }, + { + "address": "0x14000de55", + "size": 3, + "mnemonic": "cmp", + "operands": "r8, rcx" + }, + { + "address": "0x14000de58", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000de40" + }, + { + "address": "0x14000de5a", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r9 + r11*2]" + }, + { + "address": "0x14000de5e", + "size": 3, + "mnemonic": "cmp", + "operands": "r8, rax" + }, + { + "address": "0x14000de61", + "size": 2, + "mnemonic": "je", + "operands": "0x14000de73" + } + ], + "successors": [ + "0x14000de73", + "0x14000de63" + ] + }, + { + "address": "0x14000ddfe", + "size": 17, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000ddfe", + "size": 4, + "mnemonic": "add", + "operands": "rax, 2" + }, + { + "address": "0x14000de02", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, rcx" + }, + { + "address": "0x14000de05", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000ddf8" + }, + { + "address": "0x14000de07", + "size": 3, + "mnemonic": "sub", + "operands": "rax, r9" + }, + { + "address": "0x14000de0a", + "size": 3, + "mnemonic": "sar", + "operands": "rax, 1" + }, + { + "address": "0x14000de0d", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, r10" + }, + { + "address": "0x14000de10", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000dea5" + }, + { + "address": "0x14000de16", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r10" + }, + { + "address": "0x14000de19", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [r9 + rax*2]" + }, + { + "address": "0x14000de1d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdx" + }, + { + "address": "0x14000de20", + "size": 3, + "mnemonic": "xorps", + "operands": "xmm1, xmm1" + }, + { + "address": "0x14000de23", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x14000de26", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, rcx" + }, + { + "address": "0x14000de29", + "size": 3, + "mnemonic": "add", + "operands": "rdx, rax" + }, + { + "address": "0x14000de2c", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [r9 + rdx*2]" + }, + { + "address": "0x14000de30", + "size": 3, + "mnemonic": "cmp", + "operands": "r8, rcx" + }, + { + "address": "0x14000de33", + "size": 2, + "mnemonic": "je", + "operands": "0x14000de5a" + } + ], + "successors": [ + "0x14000de5a", + "0x14000de35" + ] + }, + { + "address": "0x14000ddbd", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000ddbd", + "size": 4, + "mnemonic": "add", + "operands": "rax, 2" + }, + { + "address": "0x14000ddc1", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, rcx" + }, + { + "address": "0x14000ddc4", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000ddb3" + }, + { + "address": "0x14000ddc6", + "size": 3, + "mnemonic": "sub", + "operands": "rax, r9" + }, + { + "address": "0x14000ddc9", + "size": 3, + "mnemonic": "sar", + "operands": "rax, 1" + }, + { + "address": "0x14000ddcc", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000dd87", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000dd87", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r8" + }, + { + "address": "0x14000dd8a", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x14000dd8d", + "size": 3, + "mnemonic": "sar", + "operands": "rdx, 1" + }, + { + "address": "0x14000dd90", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdx" + }, + { + "address": "0x14000dd93", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000dd77", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000dd77", + "size": 5, + "mnemonic": "cmp", + "operands": "word ptr [r8], 0" + }, + { + "address": "0x14000dd7c", + "size": 2, + "mnemonic": "je", + "operands": "0x14000dd87" + } + ], + "successors": [ + "0x14000dd87", + "0x14000dd7e" + ] + }, + { + "address": "0x14000de73", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000de73", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r8" + }, + { + "address": "0x14000de76", + "size": 3, + "mnemonic": "sub", + "operands": "rax, r9" + }, + { + "address": "0x14000de79", + "size": 3, + "mnemonic": "sar", + "operands": "rax, 1" + }, + { + "address": "0x14000de7c", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000de63", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000de63", + "size": 5, + "mnemonic": "cmp", + "operands": "word ptr [r8], 0" + }, + { + "address": "0x14000de68", + "size": 2, + "mnemonic": "je", + "operands": "0x14000de73" + } + ], + "successors": [ + "0x14000de73", + "0x14000de6a" + ] + }, + { + "address": "0x14000dd7e", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000dd7e", + "size": 4, + "mnemonic": "add", + "operands": "r8, 2" + }, + { + "address": "0x14000dd82", + "size": 3, + "mnemonic": "cmp", + "operands": "r8, rax" + }, + { + "address": "0x14000dd85", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000dd77" + }, + { + "address": "0x14000dd87", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r8" + }, + { + "address": "0x14000dd8a", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, r9" + }, + { + "address": "0x14000dd8d", + "size": 3, + "mnemonic": "sar", + "operands": "rdx, 1" + }, + { + "address": "0x14000dd90", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdx" + }, + { + "address": "0x14000dd93", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000de6a", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000de6a", + "size": 4, + "mnemonic": "add", + "operands": "r8, 2" + }, + { + "address": "0x14000de6e", + "size": 3, + "mnemonic": "cmp", + "operands": "r8, rax" + }, + { + "address": "0x14000de71", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000de63" + }, + { + "address": "0x14000de73", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r8" + }, + { + "address": "0x14000de76", + "size": 3, + "mnemonic": "sub", + "operands": "rax, r9" + }, + { + "address": "0x14000de79", + "size": 3, + "mnemonic": "sar", + "operands": "rax, 1" + }, + { + "address": "0x14000de7c", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140017230", + "name": "", + "blocks": [ + { + "address": "0x140017230", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017230", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x1bfb9], 0" + }, + { + "address": "0x140017237", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001724c" + }, + { + "address": "0x140017239", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001723c", + "size": 2, + "mnemonic": "je", + "operands": "0x140017247" + } + ], + "successors": [ + "0x140017247", + "0x14001723e" + ] + }, + { + "address": "0x140017247", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140017247", + "size": 5, + "mnemonic": "jmp", + "operands": "0x1400171a0" + } + ], + "successors": [ + "0x1400171a0" + ] + }, + { + "address": "0x14001723e", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001723e", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x140017241", + "size": 6, + "mnemonic": "jne", + "operands": "0x1400171d0" + }, + { + "address": "0x140017247", + "size": 5, + "mnemonic": "jmp", + "operands": "0x1400171a0" + } + ], + "successors": [ + "0x1400171a0" + ] + }, + { + "address": "0x1400171a0", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400171a0", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400171a4", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x1400171a7", + "size": 2, + "mnemonic": "je", + "operands": "0x1400171ae" + } + ], + "successors": [ + "0x1400171ae", + "0x1400171a9" + ] + }, + { + "address": "0x1400171ae", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400171ae", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x1400171b3", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0x16" + }, + { + "address": "0x1400171b9", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afb4" + }, + { + "address": "0x1400171be", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x7fffffff" + }, + { + "address": "0x1400171c3", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400171c7", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400171a9", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400171a9", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x1400171ac", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400171be" + }, + { + "address": "0x1400171ae", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x1400171b3", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0x16" + }, + { + "address": "0x1400171b9", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afb4" + }, + { + "address": "0x1400171be", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x7fffffff" + }, + { + "address": "0x1400171c3", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400171c7", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001d690", + "name": "", + "blocks": [ + { + "address": "0x14001d690", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001d690", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rcx" + }, + { + "address": "0x14001d693", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, word ptr [rdx]" + }, + { + "address": "0x14001d696", + "size": 4, + "mnemonic": "movzx", + "operands": "eax, word ptr [r8]" + }, + { + "address": "0x14001d69a", + "size": 2, + "mnemonic": "sub", + "operands": "eax, ecx" + }, + { + "address": "0x14001d69c", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001d6b7" + }, + { + "address": "0x14001d69e", + "size": 3, + "mnemonic": "sub", + "operands": "r8, rdx" + }, + { + "address": "0x14001d6a1", + "size": 3, + "mnemonic": "test", + "operands": "cx, cx" + }, + { + "address": "0x14001d6a4", + "size": 2, + "mnemonic": "je", + "operands": "0x14001d6b7" + } + ], + "successors": [ + "0x14001d6b7", + "0x14001d6a6" + ] + }, + { + "address": "0x14001d6b7", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001d6b7", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, eax" + }, + { + "address": "0x14001d6b9", + "size": 3, + "mnemonic": "shr", + "operands": "eax, 0x1f" + }, + { + "address": "0x14001d6bc", + "size": 2, + "mnemonic": "neg", + "operands": "ecx" + }, + { + "address": "0x14001d6be", + "size": 3, + "mnemonic": "shr", + "operands": "ecx, 0x1f" + }, + { + "address": "0x14001d6c1", + "size": 2, + "mnemonic": "sub", + "operands": "ecx, eax" + }, + { + "address": "0x14001d6c3", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ecx" + }, + { + "address": "0x14001d6c5", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001d6a6", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001d6a6", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, word ptr [rdx + 2]" + }, + { + "address": "0x14001d6aa", + "size": 4, + "mnemonic": "add", + "operands": "rdx, 2" + }, + { + "address": "0x14001d6ae", + "size": 5, + "mnemonic": "movzx", + "operands": "eax, word ptr [r8 + rdx]" + }, + { + "address": "0x14001d6b3", + "size": 2, + "mnemonic": "sub", + "operands": "eax, ecx" + }, + { + "address": "0x14001d6b5", + "size": 2, + "mnemonic": "je", + "operands": "0x14001d6a1" + } + ], + "successors": [ + "0x14001d6a1", + "0x14001d6b7" + ] + }, + { + "address": "0x14001d6a1", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001d6a1", + "size": 3, + "mnemonic": "test", + "operands": "cx, cx" + }, + { + "address": "0x14001d6a4", + "size": 2, + "mnemonic": "je", + "operands": "0x14001d6b7" + } + ], + "successors": [ + "0x14001d6b7", + "0x14001d6a6" + ] + } + ] + }, + { + "address": "0x14001c034", + "name": "", + "blocks": [ + { + "address": "0x14001c034", + "size": 16, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c034", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14001c039", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x14001c03e", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x14001c043", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001c044", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001c048", + "size": 3, + "mnemonic": "movsxd", + "operands": "rdi, r8d" + }, + { + "address": "0x14001c04b", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, ecx" + }, + { + "address": "0x14001c04e", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rdx" + }, + { + "address": "0x14001c051", + "size": 6, + "mnemonic": "test", + "operands": "ecx, 0xfffff3ff" + }, + { + "address": "0x14001c057", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001c061" + }, + { + "address": "0x14001c059", + "size": 6, + "mnemonic": "cmp", + "operands": "ecx, 0xc00" + }, + { + "address": "0x14001c05f", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001c0af" + }, + { + "address": "0x14001c061", + "size": 3, + "mnemonic": "test", + "operands": "rsi, rsi" + }, + { + "address": "0x14001c064", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001c06a" + }, + { + "address": "0x14001c066", + "size": 2, + "mnemonic": "test", + "operands": "edi, edi" + }, + { + "address": "0x14001c068", + "size": 2, + "mnemonic": "jg", + "operands": "0x14001c0af" + } + ], + "successors": [ + "0x14001c0af", + "0x14001c06a" + ] + }, + { + "address": "0x14001c0af", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001c0af", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001c0b1", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14001c0b6", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14001c0bb", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14001c0c0", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001c0c4", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001c0c5", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001c06a", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c06a", + "size": 2, + "mnemonic": "test", + "operands": "edi, edi" + }, + { + "address": "0x14001c06c", + "size": 2, + "mnemonic": "js", + "operands": "0x14001c0af" + } + ], + "successors": [ + "0x14001c0af", + "0x14001c06e" + ] + }, + { + "address": "0x14001c06e", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c06e", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x14001c071", + "size": 7, + "mnemonic": "lea", + "operands": "rbp, [rip + 0xba28]" + }, + { + "address": "0x14001c078", + "size": 6, + "mnemonic": "mov", + "operands": "r10d, 0xe3" + }, + { + "address": "0x14001c07e", + "size": 4, + "mnemonic": "lea", + "operands": "eax, [r10 + r9]" + }, + { + "address": "0x14001c082", + "size": 1, + "mnemonic": "cdq", + "operands": "" + }, + { + "address": "0x14001c083", + "size": 2, + "mnemonic": "sub", + "operands": "eax, edx" + }, + { + "address": "0x14001c085", + "size": 3, + "mnemonic": "mov", + "operands": "edx, r8d" + }, + { + "address": "0x14001c088", + "size": 2, + "mnemonic": "sar", + "operands": "eax, 1" + }, + { + "address": "0x14001c08a", + "size": 3, + "mnemonic": "movsxd", + "operands": "rcx, eax" + }, + { + "address": "0x14001c08d", + "size": 4, + "mnemonic": "shl", + "operands": "rcx, 4" + }, + { + "address": "0x14001c091", + "size": 3, + "mnemonic": "sub", + "operands": "edx, dword ptr [rcx + rbp]" + }, + { + "address": "0x14001c094", + "size": 2, + "mnemonic": "je", + "operands": "0x14001c0c6" + } + ], + "successors": [ + "0x14001c0c6", + "0x14001c096" + ] + }, + { + "address": "0x14001c0c6", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c0c6", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001c0c8", + "size": 2, + "mnemonic": "js", + "operands": "0x14001c0af" + } + ], + "successors": [ + "0x14001c0af", + "0x14001c0ca" + ] + }, + { + "address": "0x14001c096", + "size": 16, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001c096", + "size": 2, + "mnemonic": "test", + "operands": "edx, edx" + }, + { + "address": "0x14001c098", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rax - 1]" + }, + { + "address": "0x14001c09b", + "size": 4, + "mnemonic": "cmovns", + "operands": "ecx, r10d" + }, + { + "address": "0x14001c09f", + "size": 2, + "mnemonic": "inc", + "operands": "eax" + }, + { + "address": "0x14001c0a1", + "size": 2, + "mnemonic": "test", + "operands": "edx, edx" + }, + { + "address": "0x14001c0a3", + "size": 3, + "mnemonic": "mov", + "operands": "r10d, ecx" + }, + { + "address": "0x14001c0a6", + "size": 4, + "mnemonic": "cmovns", + "operands": "r9d, eax" + }, + { + "address": "0x14001c0aa", + "size": 3, + "mnemonic": "cmp", + "operands": "r9d, ecx" + }, + { + "address": "0x14001c0ad", + "size": 2, + "mnemonic": "jle", + "operands": "0x14001c07e" + }, + { + "address": "0x14001c0af", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001c0b1", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14001c0b6", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14001c0bb", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14001c0c0", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001c0c4", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001c0c5", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001c0ca", + "size": 19, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c0ca", + "size": 2, + "mnemonic": "cdqe", + "operands": "" + }, + { + "address": "0x14001c0cc", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0x55" + }, + { + "address": "0x14001c0d1", + "size": 3, + "mnemonic": "add", + "operands": "rax, rax" + }, + { + "address": "0x14001c0d4", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rbp + rax*8 + 8]" + }, + { + "address": "0x14001c0d9", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbp" + }, + { + "address": "0x14001c0dc", + "size": 5, + "mnemonic": "call", + "operands": "0x14000dca0" + }, + { + "address": "0x14001c0e1", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x14001c0e4", + "size": 2, + "mnemonic": "test", + "operands": "edi, edi" + }, + { + "address": "0x14001c0e6", + "size": 2, + "mnemonic": "jle", + "operands": "0x14001c0fe" + }, + { + "address": "0x14001c0e8", + "size": 2, + "mnemonic": "cmp", + "operands": "ebx, edi" + }, + { + "address": "0x14001c0ea", + "size": 2, + "mnemonic": "jge", + "operands": "0x14001c0af" + }, + { + "address": "0x14001c0ec", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rdi" + }, + { + "address": "0x14001c0ef", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rbp" + }, + { + "address": "0x14001c0f2", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x14001c0f5", + "size": 5, + "mnemonic": "call", + "operands": "0x1400165b0" + }, + { + "address": "0x14001c0fa", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001c0fc", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001c103" + }, + { + "address": "0x14001c0fe", + "size": 3, + "mnemonic": "lea", + "operands": "eax, [rbx + 1]" + }, + { + "address": "0x14001c101", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001c0b1" + } + ], + "successors": [ + "0x14001c0b1" + ] + }, + { + "address": "0x14001c0b1", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001c0b1", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14001c0b6", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14001c0bb", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14001c0c0", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001c0c4", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001c0c5", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001d378", + "name": "", + "blocks": [ + { + "address": "0x14001d378", + "size": 14, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001d378", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x14001d37a", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001d37e", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001d380", + "size": 3, + "mnemonic": "mov", + "operands": "r10d, ecx" + }, + { + "address": "0x14001d383", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14001d386", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001d3a1" + }, + { + "address": "0x14001d388", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x14001d38d", + "size": 5, + "mnemonic": "mov", + "operands": "ebx, 0x16" + }, + { + "address": "0x14001d392", + "size": 2, + "mnemonic": "mov", + "operands": "dword ptr [rax], ebx" + }, + { + "address": "0x14001d394", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afb4" + }, + { + "address": "0x14001d399", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ebx" + }, + { + "address": "0x14001d39b", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14001d39f", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001d3a0", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001c5a0", + "name": "", + "blocks": [ + { + "address": "0x14001c5a0", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001c5a0", + "size": 4, + "mnemonic": "and", + "operands": "qword ptr [rcx], 0" + }, + { + "address": "0x14001c5a4", + "size": 4, + "mnemonic": "or", + "operands": "rax, 0xffffffffffffffff" + }, + { + "address": "0x14001c5a8", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rdx + 0x30], 1" + }, + { + "address": "0x14001c5ac", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rdx + 0x2c], 0x2a" + }, + { + "address": "0x14001c5b3", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140004cbc", + "name": "", + "blocks": [ + { + "address": "0x140004cbc", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004cbc", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140004cbe", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140004cc2", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 8]" + }, + { + "address": "0x140004cc6", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140004cc9", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140004ccc", + "size": 2, + "mnemonic": "je", + "operands": "0x140004cde" + } + ], + "successors": [ + "0x140004cde", + "0x140004cce" + ] + }, + { + "address": "0x140004cde", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004cde", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140004ce1", + "size": 5, + "mnemonic": "call", + "operands": "0x140004d34" + }, + { + "address": "0x140004ce6", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rbx + 0x40]" + }, + { + "address": "0x140004cea", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x140004ced", + "size": 2, + "mnemonic": "je", + "operands": "0x140004d2b" + } + ], + "successors": [ + "0x140004d2b", + "0x140004cef" + ] + }, + { + "address": "0x140004cce", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004cce", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x2d85b]" + }, + { + "address": "0x140004cd5", + "size": 3, + "mnemonic": "dec", + "operands": "byte ptr [rax + rcx]" + }, + { + "address": "0x140004cd8", + "size": 4, + "mnemonic": "cmp", + "operands": "byte ptr [rax + rcx], 0" + }, + { + "address": "0x140004cdc", + "size": 2, + "mnemonic": "jg", + "operands": "0x140004d2b" + } + ], + "successors": [ + "0x140004d2b", + "0x140004cde" + ] + }, + { + "address": "0x140004d2b", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140004d2b", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140004d2f", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140004d30", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140004cef", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004cef", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 8]" + }, + { + "address": "0x140004cf3", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140004cf6", + "size": 2, + "mnemonic": "je", + "operands": "0x140004d1e" + } + ], + "successors": [ + "0x140004d1e", + "0x140004cf8" + ] + }, + { + "address": "0x140004d1e", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140004d1e", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0x10" + }, + { + "address": "0x140004d23", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140004d26", + "size": 5, + "mnemonic": "call", + "operands": "0x140005170" + }, + { + "address": "0x140004d2b", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140004d2f", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140004d30", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140004cf8", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004cf8", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x140004cfb", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rax + 0x10]" + }, + { + "address": "0x140004cff", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1b5bb]" + }, + { + "address": "0x140004d05", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x140004d08", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140004d0b", + "size": 2, + "mnemonic": "je", + "operands": "0x140004d1e" + } + ], + "successors": [ + "0x140004d1e", + "0x140004d0d" + ] + }, + { + "address": "0x140004d0d", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140004d0d", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rax]" + }, + { + "address": "0x140004d10", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rdx]" + }, + { + "address": "0x140004d13", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 1" + }, + { + "address": "0x140004d18", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1b5a2]" + }, + { + "address": "0x140004d1e", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0x10" + }, + { + "address": "0x140004d23", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140004d26", + "size": 5, + "mnemonic": "call", + "operands": "0x140005170" + }, + { + "address": "0x140004d2b", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140004d2f", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140004d30", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000a704", + "name": "", + "blocks": [ + { + "address": "0x14000a704", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a704", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x15ba5]" + }, + { + "address": "0x14000a70b", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip - 0x728a]" + }, + { + "address": "0x14000a712", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, rdx" + }, + { + "address": "0x14000a715", + "size": 2, + "mnemonic": "je", + "operands": "0x14000a73a" + } + ], + "successors": [ + "0x14000a73a", + "0x14000a717" + ] + }, + { + "address": "0x14000a73a", + "size": 1, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000a73a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000a717", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a717", + "size": 9, + "mnemonic": "mov", + "operands": "rax, qword ptr gs:[0x30]" + }, + { + "address": "0x14000a720", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x98]" + }, + { + "address": "0x14000a727", + "size": 4, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rax + 0x10]" + }, + { + "address": "0x14000a72b", + "size": 2, + "mnemonic": "jb", + "operands": "0x14000a733" + } + ], + "successors": [ + "0x14000a733", + "0x14000a72d" + ] + }, + { + "address": "0x14000a733", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000a733", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0xd" + }, + { + "address": "0x14000a738", + "size": 2, + "mnemonic": "int", + "operands": "0x29" + }, + { + "address": "0x14000a73a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000a72d", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000a72d", + "size": 4, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rax + 8]" + }, + { + "address": "0x14000a731", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14000a73a" + }, + { + "address": "0x14000a733", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 0xd" + }, + { + "address": "0x14000a738", + "size": 2, + "mnemonic": "int", + "operands": "0x29" + }, + { + "address": "0x14000a73a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400064ac", + "name": "", + "blocks": [ + { + "address": "0x1400064ac", + "size": 19, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400064ac", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x1400064b1", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rsi" + }, + { + "address": "0x1400064b6", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x1400064b7", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400064bb", + "size": 5, + "mnemonic": "lea", + "operands": "r9, [rsp + 0x48]" + }, + { + "address": "0x1400064c0", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r8" + }, + { + "address": "0x1400064c3", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x1400064c6", + "size": 5, + "mnemonic": "call", + "operands": "0x140006544" + }, + { + "address": "0x1400064cb", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rdi" + }, + { + "address": "0x1400064ce", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x1400064d1", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rax" + }, + { + "address": "0x1400064d4", + "size": 5, + "mnemonic": "call", + "operands": "0x1400075d8" + }, + { + "address": "0x1400064d9", + "size": 2, + "mnemonic": "mov", + "operands": "edx, eax" + }, + { + "address": "0x1400064db", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x1400064de", + "size": 5, + "mnemonic": "call", + "operands": "0x1400062e8" + }, + { + "address": "0x1400064e3", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x1400064e6", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400064ee" + }, + { + "address": "0x1400064e8", + "size": 4, + "mnemonic": "or", + "operands": "r9d, 0xffffffff" + }, + { + "address": "0x1400064ec", + "size": 2, + "mnemonic": "jmp", + "operands": "0x1400064f2" + } + ], + "successors": [ + "0x1400064f2" + ] + }, + { + "address": "0x1400064f2", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400064f2", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rbx" + }, + { + "address": "0x1400064f5", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rdi" + }, + { + "address": "0x1400064f8", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x1400064fb", + "size": 5, + "mnemonic": "call", + "operands": "0x140009dc4" + }, + { + "address": "0x140006500", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140006505", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14000650a", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000650e", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000650f", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400075e8", + "name": "", + "blocks": [ + ] + }, + { + "address": "0x140009dc4", + "name": "", + "blocks": [ + { + "address": "0x140009dc4", + "size": 27, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009dc4", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x20], r9d" + }, + { + "address": "0x140009dc9", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], r8" + }, + { + "address": "0x140009dce", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rcx" + }, + { + "address": "0x140009dd3", + "size": 1, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140009dd4", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140009dd5", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140009dd6", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140009dd8", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140009dda", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140009ddc", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140009dde", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x140009de2", + "size": 3, + "mnemonic": "mov", + "operands": "r12d, r9d" + }, + { + "address": "0x140009de5", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, r8" + }, + { + "address": "0x140009de8", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdx" + }, + { + "address": "0x140009deb", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rcx" + }, + { + "address": "0x140009dee", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140009df3", + "size": 3, + "mnemonic": "mov", + "operands": "r13, rax" + }, + { + "address": "0x140009df6", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x28], rax" + }, + { + "address": "0x140009dfb", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rsi" + }, + { + "address": "0x140009dfe", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x140009e01", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r15" + }, + { + "address": "0x140009e04", + "size": 5, + "mnemonic": "call", + "operands": "0x14000753c" + }, + { + "address": "0x140009e09", + "size": 2, + "mnemonic": "mov", + "operands": "edi, eax" + }, + { + "address": "0x140009e0b", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140009e10", + "size": 3, + "mnemonic": "inc", + "operands": "dword ptr [rax + 0x30]" + }, + { + "address": "0x140009e13", + "size": 3, + "mnemonic": "cmp", + "operands": "edi, -1" + }, + { + "address": "0x140009e16", + "size": 6, + "mnemonic": "je", + "operands": "0x140009f06" + } + ], + "successors": [ + "0x140009f06", + "0x140009e1c" + ] + }, + { + "address": "0x140009f06", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009f06", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140009f0b", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rax + 0x30], 0" + }, + { + "address": "0x140009f0f", + "size": 2, + "mnemonic": "jle", + "operands": "0x140009f19" + }, + { + "address": "0x140009f11", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140009f16", + "size": 3, + "mnemonic": "dec", + "operands": "dword ptr [rax + 0x30]" + }, + { + "address": "0x140009f19", + "size": 3, + "mnemonic": "cmp", + "operands": "edi, -1" + }, + { + "address": "0x140009f1c", + "size": 2, + "mnemonic": "je", + "operands": "0x140009f23" + } + ], + "successors": [ + "0x140009f23", + "0x140009f1e" + ] + }, + { + "address": "0x140009e1c", + "size": 18, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009e1c", + "size": 3, + "mnemonic": "cmp", + "operands": "edi, r12d" + }, + { + "address": "0x140009e1f", + "size": 6, + "mnemonic": "jle", + "operands": "0x140009f06" + }, + { + "address": "0x140009e25", + "size": 3, + "mnemonic": "cmp", + "operands": "edi, -1" + }, + { + "address": "0x140009e28", + "size": 6, + "mnemonic": "jle", + "operands": "0x140009f41" + }, + { + "address": "0x140009e2e", + "size": 3, + "mnemonic": "cmp", + "operands": "edi, dword ptr [rsi + 4]" + }, + { + "address": "0x140009e31", + "size": 6, + "mnemonic": "jge", + "operands": "0x140009f41" + }, + { + "address": "0x140009e37", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140009e3c", + "size": 3, + "mnemonic": "movsxd", + "operands": "r14, edi" + }, + { + "address": "0x140009e3f", + "size": 4, + "mnemonic": "shl", + "operands": "r14, 3" + }, + { + "address": "0x140009e43", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rsi + 8]" + }, + { + "address": "0x140009e47", + "size": 3, + "mnemonic": "add", + "operands": "rcx, r14" + }, + { + "address": "0x140009e4a", + "size": 3, + "mnemonic": "mov", + "operands": "edi, dword ptr [rcx + rax]" + }, + { + "address": "0x140009e4d", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x20], edi" + }, + { + "address": "0x140009e51", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rsi + 8]" + }, + { + "address": "0x140009e55", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140009e5a", + "size": 3, + "mnemonic": "add", + "operands": "rax, r14" + }, + { + "address": "0x140009e5d", + "size": 5, + "mnemonic": "cmp", + "operands": "dword ptr [rax + rbx + 4], 0" + }, + { + "address": "0x140009e62", + "size": 2, + "mnemonic": "je", + "operands": "0x140009e7f" + } + ], + "successors": [ + "0x140009e7f", + "0x140009e64" + ] + }, + { + "address": "0x140009f23", + "size": 13, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140009f23", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, edi" + }, + { + "address": "0x140009f26", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x140009f29", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r15" + }, + { + "address": "0x140009f2c", + "size": 5, + "mnemonic": "call", + "operands": "0x140007590" + }, + { + "address": "0x140009f31", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140009f35", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x140009f37", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140009f39", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x140009f3b", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140009f3d", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140009f3e", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x140009f3f", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140009f40", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140009f1e", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009f1e", + "size": 3, + "mnemonic": "cmp", + "operands": "edi, r12d" + }, + { + "address": "0x140009f21", + "size": 2, + "mnemonic": "jg", + "operands": "0x140009f47" + } + ], + "successors": [ + "0x140009f47", + "0x140009f23" + ] + }, + { + "address": "0x140009e7f", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009e7f", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140009e81", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140009e84", + "size": 2, + "mnemonic": "je", + "operands": "0x140009edd" + } + ], + "successors": [ + "0x140009edd", + "0x140009e86" + ] + }, + { + "address": "0x140009e64", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009e64", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rsi + 8]" + }, + { + "address": "0x140009e68", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140009e6d", + "size": 3, + "mnemonic": "add", + "operands": "rax, r14" + }, + { + "address": "0x140009e70", + "size": 5, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rax + rbx + 4]" + }, + { + "address": "0x140009e75", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140009e7a", + "size": 3, + "mnemonic": "add", + "operands": "rax, rbx" + }, + { + "address": "0x140009e7d", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140009e81" + } + ], + "successors": [ + "0x140009e81" + ] + }, + { + "address": "0x140009f47", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009f47", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140009f4c", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140009f4d", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140009edd", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009edd", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140009efd" + } + ], + "successors": [ + "0x140009efd" + ] + }, + { + "address": "0x140009e86", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009e86", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, edi" + }, + { + "address": "0x140009e89", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x140009e8c", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r15" + }, + { + "address": "0x140009e8f", + "size": 5, + "mnemonic": "call", + "operands": "0x140007590" + }, + { + "address": "0x140009e94", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rsi + 8]" + }, + { + "address": "0x140009e98", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140009e9d", + "size": 3, + "mnemonic": "add", + "operands": "rax, r14" + }, + { + "address": "0x140009ea0", + "size": 5, + "mnemonic": "cmp", + "operands": "dword ptr [rax + rbx + 4], 0" + }, + { + "address": "0x140009ea5", + "size": 2, + "mnemonic": "je", + "operands": "0x140009ec2" + } + ], + "successors": [ + "0x140009ec2", + "0x140009ea7" + ] + }, + { + "address": "0x140009e81", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009e81", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140009e84", + "size": 2, + "mnemonic": "je", + "operands": "0x140009edd" + } + ], + "successors": [ + "0x140009edd", + "0x140009e86" + ] + }, + { + "address": "0x140009efd", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009efd", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x24], edi" + }, + { + "address": "0x140009f01", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140009e13" + } + ], + "successors": [ + "0x140009e13" + ] + }, + { + "address": "0x140009ec2", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009ec2", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x140009ec4", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x103" + }, + { + "address": "0x140009eca", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r15" + }, + { + "address": "0x140009ecd", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x140009ed0", + "size": 5, + "mnemonic": "call", + "operands": "0x14000aae0" + }, + { + "address": "0x140009ed5", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r13" + }, + { + "address": "0x140009ed8", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dd0" + }, + { + "address": "0x140009edd", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140009efd" + } + ], + "successors": [ + "0x140009efd" + ] + }, + { + "address": "0x140009ea7", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009ea7", + "size": 4, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rsi + 8]" + }, + { + "address": "0x140009eab", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140009eb0", + "size": 3, + "mnemonic": "add", + "operands": "rax, r14" + }, + { + "address": "0x140009eb3", + "size": 5, + "mnemonic": "movsxd", + "operands": "rbx, dword ptr [rax + rbx + 4]" + }, + { + "address": "0x140009eb8", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140009ebd", + "size": 3, + "mnemonic": "add", + "operands": "rax, rbx" + }, + { + "address": "0x140009ec0", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140009ec4" + } + ], + "successors": [ + "0x140009ec4" + ] + }, + { + "address": "0x140009e13", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009e13", + "size": 3, + "mnemonic": "cmp", + "operands": "edi, -1" + }, + { + "address": "0x140009e16", + "size": 6, + "mnemonic": "je", + "operands": "0x140009f06" + } + ], + "successors": [ + "0x140009f06", + "0x140009e1c" + ] + }, + { + "address": "0x140009ec4", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009ec4", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x103" + }, + { + "address": "0x140009eca", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r15" + }, + { + "address": "0x140009ecd", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x140009ed0", + "size": 5, + "mnemonic": "call", + "operands": "0x14000aae0" + }, + { + "address": "0x140009ed5", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r13" + }, + { + "address": "0x140009ed8", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dd0" + }, + { + "address": "0x140009edd", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140009efd" + } + ], + "successors": [ + "0x140009efd" + ] + } + ] + }, + { + "address": "0x140009284", + "name": "", + "blocks": [ + { + "address": "0x140009284", + "size": 25, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009284", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsp" + }, + { + "address": "0x140009287", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 8], rbx" + }, + { + "address": "0x14000928b", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x10], rbp" + }, + { + "address": "0x14000928f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x18], rsi" + }, + { + "address": "0x140009293", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x20], rdi" + }, + { + "address": "0x140009297", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140009299", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000929b", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14000929d", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x80" + }, + { + "address": "0x1400092a4", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x1400092a7", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, r9" + }, + { + "address": "0x1400092aa", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r8" + }, + { + "address": "0x1400092ad", + "size": 3, + "mnemonic": "mov", + "operands": "r12, r8" + }, + { + "address": "0x1400092b0", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rdx" + }, + { + "address": "0x1400092b3", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a704" + }, + { + "address": "0x1400092b8", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x1400092bd", + "size": 8, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0xc0]" + }, + { + "address": "0x1400092c5", + "size": 2, + "mnemonic": "xor", + "operands": "ebp, ebp" + }, + { + "address": "0x1400092c7", + "size": 6, + "mnemonic": "mov", + "operands": "r14d, 0xe06d7363" + }, + { + "address": "0x1400092cd", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x80000029" + }, + { + "address": "0x1400092d3", + "size": 6, + "mnemonic": "mov", + "operands": "r9d, 0x80000026" + }, + { + "address": "0x1400092d9", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rax + 0x40], ebp" + }, + { + "address": "0x1400092dc", + "size": 2, + "mnemonic": "jne", + "operands": "0x140009306" + }, + { + "address": "0x1400092de", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rbx], r14d" + }, + { + "address": "0x1400092e1", + "size": 2, + "mnemonic": "je", + "operands": "0x140009306" + } + ], + "successors": [ + "0x140009306", + "0x1400092e3" + ] + }, + { + "address": "0x140009306", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009306", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [rbx + 4], 0x66" + }, + { + "address": "0x14000930a", + "size": 6, + "mnemonic": "je", + "operands": "0x140009435" + } + ], + "successors": [ + "0x140009435", + "0x140009310" + ] + }, + { + "address": "0x1400092e3", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400092e3", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rbx], r8d" + }, + { + "address": "0x1400092e6", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400092f8" + }, + { + "address": "0x1400092e8", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rbx + 0x18], 0xf" + }, + { + "address": "0x1400092ec", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400092fd" + }, + { + "address": "0x1400092ee", + "size": 8, + "mnemonic": "cmp", + "operands": "qword ptr [rbx + 0x60], 0x19930520" + }, + { + "address": "0x1400092f6", + "size": 2, + "mnemonic": "je", + "operands": "0x140009306" + } + ], + "successors": [ + "0x140009306", + "0x1400092f8" + ] + }, + { + "address": "0x140009435", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009435", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsi + 8]" + }, + { + "address": "0x140009439", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x50]" + }, + { + "address": "0x14000943e", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rdi" + }, + { + "address": "0x140009441", + "size": 5, + "mnemonic": "call", + "operands": "0x140009604" + }, + { + "address": "0x140009446", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rsp + 0x50], ebp" + }, + { + "address": "0x14000944a", + "size": 2, + "mnemonic": "jne", + "operands": "0x140009455" + }, + { + "address": "0x14000944c", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [rdi], 0x40" + }, + { + "address": "0x14000944f", + "size": 6, + "mnemonic": "je", + "operands": "0x1400094fc" + } + ], + "successors": [ + "0x1400094fc", + "0x140009455" + ] + }, + { + "address": "0x140009310", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009310", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rdi + 8], ebp" + }, + { + "address": "0x140009313", + "size": 6, + "mnemonic": "je", + "operands": "0x1400094fc" + } + ], + "successors": [ + "0x1400094fc", + "0x140009319" + ] + }, + { + "address": "0x1400092f8", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400092f8", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rbx], r9d" + }, + { + "address": "0x1400092fb", + "size": 2, + "mnemonic": "je", + "operands": "0x140009306" + } + ], + "successors": [ + "0x140009306", + "0x1400092fd" + ] + }, + { + "address": "0x1400094fc", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400094fc", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 1" + }, + { + "address": "0x140009501", + "size": 8, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x80]" + }, + { + "address": "0x140009509", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x20]" + }, + { + "address": "0x14000950d", + "size": 4, + "mnemonic": "mov", + "operands": "rbp, qword ptr [r11 + 0x28]" + }, + { + "address": "0x140009511", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x30]" + }, + { + "address": "0x140009515", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x38]" + }, + { + "address": "0x140009519", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x14000951c", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000951e", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140009520", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140009522", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140009455", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009455", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rbx], r14d" + }, + { + "address": "0x140009458", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400094c3" + }, + { + "address": "0x14000945a", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rbx + 0x18], 3" + }, + { + "address": "0x14000945e", + "size": 2, + "mnemonic": "jb", + "operands": "0x1400094c3" + } + ], + "successors": [ + "0x1400094c3", + "0x140009460" + ] + }, + { + "address": "0x140009319", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009319", + "size": 4, + "mnemonic": "movsxd", + "operands": "rcx, dword ptr [rdi + 8]" + }, + { + "address": "0x14000931d", + "size": 7, + "mnemonic": "lea", + "operands": "r14, [rip - 0x9324]" + }, + { + "address": "0x140009324", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rsi + 8]" + }, + { + "address": "0x140009328", + "size": 3, + "mnemonic": "add", + "operands": "rdx, rcx" + }, + { + "address": "0x14000932b", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x14000932e", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x140009331", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r14 + 0x23d90]" + }, + { + "address": "0x14000933a", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r14 + 0x23da0]" + }, + { + "address": "0x140009342", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, rax" + }, + { + "address": "0x140009345", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x140009348", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x14000934a", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000934c", + "size": 6, + "mnemonic": "je", + "operands": "0x1400094fc" + } + ], + "successors": [ + "0x1400094fc", + "0x140009352" + ] + }, + { + "address": "0x1400092fd", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400092fd", + "size": 3, + "mnemonic": "test", + "operands": "byte ptr [rdi], 0x20" + }, + { + "address": "0x140009300", + "size": 6, + "mnemonic": "jne", + "operands": "0x1400094fc" + }, + { + "address": "0x140009306", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [rbx + 4], 0x66" + }, + { + "address": "0x14000930a", + "size": 6, + "mnemonic": "je", + "operands": "0x140009435" + } + ], + "successors": [ + "0x140009435", + "0x140009310" + ] + }, + { + "address": "0x1400094c3", + "size": 23, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400094c3", + "size": 8, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0xd0]" + }, + { + "address": "0x1400094cb", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rsi" + }, + { + "address": "0x1400094ce", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], rax" + }, + { + "address": "0x1400094d3", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r12" + }, + { + "address": "0x1400094d6", + "size": 7, + "mnemonic": "mov", + "operands": "eax, dword ptr [rsp + 0xc8]" + }, + { + "address": "0x1400094dd", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r15" + }, + { + "address": "0x1400094e0", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x30], eax" + }, + { + "address": "0x1400094e4", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x1400094e7", + "size": 7, + "mnemonic": "mov", + "operands": "al, byte ptr [rsp + 0xd8]" + }, + { + "address": "0x1400094ee", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x28], al" + }, + { + "address": "0x1400094f2", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rdi" + }, + { + "address": "0x1400094f7", + "size": 5, + "mnemonic": "call", + "operands": "0x140008350" + }, + { + "address": "0x1400094fc", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 1" + }, + { + "address": "0x140009501", + "size": 8, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x80]" + }, + { + "address": "0x140009509", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x20]" + }, + { + "address": "0x14000950d", + "size": 4, + "mnemonic": "mov", + "operands": "rbp, qword ptr [r11 + 0x28]" + }, + { + "address": "0x140009511", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x30]" + }, + { + "address": "0x140009515", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x38]" + }, + { + "address": "0x140009519", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x14000951c", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000951e", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140009520", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140009522", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140009460", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009460", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rbx + 0x20], 0x19930522" + }, + { + "address": "0x140009467", + "size": 2, + "mnemonic": "jbe", + "operands": "0x1400094c3" + }, + { + "address": "0x140009469", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx + 0x30]" + }, + { + "address": "0x14000946d", + "size": 4, + "mnemonic": "movsxd", + "operands": "r14, dword ptr [rax + 8]" + }, + { + "address": "0x140009471", + "size": 3, + "mnemonic": "test", + "operands": "r14d, r14d" + }, + { + "address": "0x140009474", + "size": 2, + "mnemonic": "je", + "operands": "0x1400094c3" + } + ], + "successors": [ + "0x1400094c3", + "0x140009476" + ] + }, + { + "address": "0x140009352", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009352", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rsp + 0xc8], ebp" + }, + { + "address": "0x140009359", + "size": 6, + "mnemonic": "jne", + "operands": "0x1400094fc" + }, + { + "address": "0x14000935f", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [rbx + 4], 0x20" + }, + { + "address": "0x140009363", + "size": 6, + "mnemonic": "je", + "operands": "0x140009422" + } + ], + "successors": [ + "0x140009422", + "0x140009369" + ] + }, + { + "address": "0x140009476", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009476", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dbc" + }, + { + "address": "0x14000947b", + "size": 3, + "mnemonic": "mov", + "operands": "r10, rax" + }, + { + "address": "0x14000947e", + "size": 3, + "mnemonic": "add", + "operands": "r10, r14" + }, + { + "address": "0x140009481", + "size": 2, + "mnemonic": "je", + "operands": "0x1400094c3" + } + ], + "successors": [ + "0x1400094c3", + "0x140009483" + ] + }, + { + "address": "0x140009422", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009422", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rdi" + }, + { + "address": "0x140009425", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x140009428", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r15" + }, + { + "address": "0x14000942b", + "size": 5, + "mnemonic": "call", + "operands": "0x140006510" + }, + { + "address": "0x140009430", + "size": 5, + "mnemonic": "jmp", + "operands": "0x1400094fc" + } + ], + "successors": [ + "0x1400094fc" + ] + }, + { + "address": "0x140009369", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009369", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rbx], r9d" + }, + { + "address": "0x14000936c", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400093d6" + }, + { + "address": "0x14000936e", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsi + 0x20]" + }, + { + "address": "0x140009372", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x140009375", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140009378", + "size": 5, + "mnemonic": "call", + "operands": "0x140007650" + }, + { + "address": "0x14000937d", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, eax" + }, + { + "address": "0x140009380", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, -1" + }, + { + "address": "0x140009383", + "size": 6, + "mnemonic": "jl", + "operands": "0x140009523" + } + ], + "successors": [ + "0x140009523", + "0x140009389" + ] + }, + { + "address": "0x140009483", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009483", + "size": 8, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rsp + 0xd8]" + }, + { + "address": "0x14000948b", + "size": 3, + "mnemonic": "mov", + "operands": "r9, rsi" + }, + { + "address": "0x14000948e", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x38], ecx" + }, + { + "address": "0x140009492", + "size": 3, + "mnemonic": "mov", + "operands": "r8, r12" + }, + { + "address": "0x140009495", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0xd0]" + }, + { + "address": "0x14000949d", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r15" + }, + { + "address": "0x1400094a0", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rcx" + }, + { + "address": "0x1400094a5", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r10" + }, + { + "address": "0x1400094a8", + "size": 7, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rsp + 0xc8]" + }, + { + "address": "0x1400094af", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x28], ecx" + }, + { + "address": "0x1400094b3", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x1400094b6", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rdi" + }, + { + "address": "0x1400094bb", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x16dff]" + }, + { + "address": "0x1400094c1", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140009501" + } + ], + "successors": [ + "0x140009501" + ] + }, + { + "address": "0x140009523", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009523", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x140009528", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140009389", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009389", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rdi + 8], ebp" + }, + { + "address": "0x14000938c", + "size": 2, + "mnemonic": "je", + "operands": "0x1400093ba" + } + ], + "successors": [ + "0x1400093ba", + "0x14000938e" + ] + }, + { + "address": "0x140009501", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140009501", + "size": 8, + "mnemonic": "lea", + "operands": "r11, [rsp + 0x80]" + }, + { + "address": "0x140009509", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r11 + 0x20]" + }, + { + "address": "0x14000950d", + "size": 4, + "mnemonic": "mov", + "operands": "rbp, qword ptr [r11 + 0x28]" + }, + { + "address": "0x140009511", + "size": 4, + "mnemonic": "mov", + "operands": "rsi, qword ptr [r11 + 0x30]" + }, + { + "address": "0x140009515", + "size": 4, + "mnemonic": "mov", + "operands": "rdi, qword ptr [r11 + 0x38]" + }, + { + "address": "0x140009519", + "size": 3, + "mnemonic": "mov", + "operands": "rsp, r11" + }, + { + "address": "0x14000951c", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000951e", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x140009520", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x140009522", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400093ba", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400093ba", + "size": 3, + "mnemonic": "cmp", + "operands": "r9d, ebp" + }, + { + "address": "0x1400093bd", + "size": 6, + "mnemonic": "jge", + "operands": "0x140009523" + }, + { + "address": "0x1400093c3", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r15" + }, + { + "address": "0x1400093c6", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x1400093c9", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rdi" + }, + { + "address": "0x1400093cc", + "size": 5, + "mnemonic": "call", + "operands": "0x140009f50" + }, + { + "address": "0x1400093d1", + "size": 5, + "mnemonic": "jmp", + "operands": "0x1400094fc" + } + ], + "successors": [ + "0x1400094fc" + ] + }, + { + "address": "0x14000938e", + "size": 17, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000938e", + "size": 4, + "mnemonic": "movsxd", + "operands": "rdx, dword ptr [rdi + 8]" + }, + { + "address": "0x140009392", + "size": 4, + "mnemonic": "mov", + "operands": "r8, qword ptr [rsi + 8]" + }, + { + "address": "0x140009396", + "size": 3, + "mnemonic": "add", + "operands": "r8, rdx" + }, + { + "address": "0x140009399", + "size": 4, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [r8]" + }, + { + "address": "0x14000939d", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x1400093a0", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r14 + 0x23d90]" + }, + { + "address": "0x1400093a9", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r14 + 0x23da0]" + }, + { + "address": "0x1400093b1", + "size": 3, + "mnemonic": "sub", + "operands": "r8, rax" + }, + { + "address": "0x1400093b4", + "size": 4, + "mnemonic": "mov", + "operands": "ebp, dword ptr [r8 - 4]" + }, + { + "address": "0x1400093b8", + "size": 2, + "mnemonic": "shr", + "operands": "ebp, cl" + }, + { + "address": "0x1400093ba", + "size": 3, + "mnemonic": "cmp", + "operands": "r9d, ebp" + }, + { + "address": "0x1400093bd", + "size": 6, + "mnemonic": "jge", + "operands": "0x140009523" + }, + { + "address": "0x1400093c3", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r15" + }, + { + "address": "0x1400093c6", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x1400093c9", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rdi" + }, + { + "address": "0x1400093cc", + "size": 5, + "mnemonic": "call", + "operands": "0x140009f50" + }, + { + "address": "0x1400093d1", + "size": 5, + "mnemonic": "jmp", + "operands": "0x1400094fc" + } + ], + "successors": [ + "0x1400094fc" + ] + } + ] + }, + { + "address": "0x14000aa38", + "name": "", + "blocks": [ + { + "address": "0x14000aa38", + "size": 16, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000aa38", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000aa3d", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rsi" + }, + { + "address": "0x14000aa42", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000aa43", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000aa47", + "size": 3, + "mnemonic": "mov", + "operands": "esi, r8d" + }, + { + "address": "0x14000aa4a", + "size": 7, + "mnemonic": "lea", + "operands": "r9, [rip + 0x1a3bf]" + }, + { + "address": "0x14000aa51", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, edx" + }, + { + "address": "0x14000aa53", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip + 0x1a3ae]" + }, + { + "address": "0x14000aa5a", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x14000aa5d", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x1a3ac]" + }, + { + "address": "0x14000aa64", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 4" + }, + { + "address": "0x14000aa69", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a7bc" + }, + { + "address": "0x14000aa6e", + "size": 2, + "mnemonic": "mov", + "operands": "edx, ebx" + }, + { + "address": "0x14000aa70", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x14000aa73", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000aa76", + "size": 2, + "mnemonic": "je", + "operands": "0x14000aa83" + } + ], + "successors": [ + "0x14000aa83", + "0x14000aa78" + ] + }, + { + "address": "0x14000aa83", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000aa83", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1567f]" + }, + { + "address": "0x14000aa89", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000aa8e", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14000aa93", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000aa97", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000aa98", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000aa78", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000aa78", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, esi" + }, + { + "address": "0x14000aa7b", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x1583f]" + }, + { + "address": "0x14000aa81", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000aa89" + } + ], + "successors": [ + "0x14000aa89" + ] + }, + { + "address": "0x14000aa89", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000aa89", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000aa8e", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14000aa93", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000aa97", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000aa98", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000a954", + "name": "", + "blocks": [ + { + "address": "0x14000a954", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a954", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x14000a956", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a95a", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, ecx" + }, + { + "address": "0x14000a95c", + "size": 7, + "mnemonic": "lea", + "operands": "r9, [rip + 0x1a46d]" + }, + { + "address": "0x14000a963", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 1" + }, + { + "address": "0x14000a968", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip + 0x1a459]" + }, + { + "address": "0x14000a96f", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x1a45a]" + }, + { + "address": "0x14000a976", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a7bc" + }, + { + "address": "0x14000a97b", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, ebx" + }, + { + "address": "0x14000a97d", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000a980", + "size": 2, + "mnemonic": "je", + "operands": "0x14000a98e" + } + ], + "successors": [ + "0x14000a98e", + "0x14000a982" + ] + }, + { + "address": "0x14000a98e", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a98e", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a992", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000a993", + "size": 7, + "mnemonic": "jmp", + "operands": "qword ptr [rip + 0x1578e]" + } + ], + "successors": [ + "0x140020128" + ] + }, + { + "address": "0x14000a982", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a982", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a986", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000a987", + "size": 7, + "mnemonic": "jmp", + "operands": "qword ptr [rip + 0x15932]" + } + ], + "successors": [ + "0x14001e360" + ] + }, + { + "address": "0x140020128", + "size": 0, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140010944", + "name": "", + "blocks": [ + { + "address": "0x140010944", + "size": 17, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140010944", + "size": 3, + "mnemonic": "mov", + "operands": "r11, rsp" + }, + { + "address": "0x140010947", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r11 + 8], rcx" + }, + { + "address": "0x14001094b", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x38" + }, + { + "address": "0x14001094f", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [r11 - 0x10], 0xfffffffffffffffe" + }, + { + "address": "0x140010957", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [r11 + 8]" + }, + { + "address": "0x14001095b", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r11 - 0x18], rax" + }, + { + "address": "0x14001095f", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 2" + }, + { + "address": "0x140010964", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x50], eax" + }, + { + "address": "0x140010968", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x58], eax" + }, + { + "address": "0x14001096c", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [r11 + 0x18]" + }, + { + "address": "0x140010970", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [r11 - 0x18]" + }, + { + "address": "0x140010974", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [r11 + 0x20]" + }, + { + "address": "0x140010978", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [r11 + 0x10]" + }, + { + "address": "0x14001097c", + "size": 5, + "mnemonic": "call", + "operands": "0x140010630" + }, + { + "address": "0x140010981", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x140010982", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x38" + }, + { + "address": "0x140010986", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400022c0", + "name": "", + "blocks": [ + { + "address": "0x1400022c0", + "size": 19, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400022c0", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x1400022c2", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x1400022c6", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x1400022c9", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x28], 1" + }, + { + "address": "0x1400022ce", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdx" + }, + { + "address": "0x1400022d1", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x1e110]" + }, + { + "address": "0x1400022d8", + "size": 3, + "mnemonic": "xorps", + "operands": "xmm0, xmm0" + }, + { + "address": "0x1400022db", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x1400022e0", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rbx], rcx" + }, + { + "address": "0x1400022e3", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbx + 8]" + }, + { + "address": "0x1400022e7", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x20]" + }, + { + "address": "0x1400022ec", + "size": 3, + "mnemonic": "movups", + "operands": "xmmword ptr [rdx], xmm0" + }, + { + "address": "0x1400022ef", + "size": 5, + "mnemonic": "call", + "operands": "0x1400060f0" + }, + { + "address": "0x1400022f4", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1e2bd]" + }, + { + "address": "0x1400022fb", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rbx], rax" + }, + { + "address": "0x1400022fe", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140002301", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140002305", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140002306", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140001dd0", + "name": "", + "blocks": [ + { + "address": "0x140001dd0", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140001dd0", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x48" + }, + { + "address": "0x140001dd4", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x20]" + }, + { + "address": "0x140001dd9", + "size": 5, + "mnemonic": "call", + "operands": "0x1400018b0" + }, + { + "address": "0x140001dde", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x2deab]" + }, + { + "address": "0x140001de5", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x20]" + }, + { + "address": "0x140001dea", + "size": 5, + "mnemonic": "call", + "operands": "0x140006198" + }, + { + "address": "0x140001def", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400047dc", + "name": "", + "blocks": [ + { + "address": "0x1400047dc", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400047dc", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400047e0", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rcx + 0x48]" + }, + { + "address": "0x1400047e4", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x1400047e7", + "size": 2, + "mnemonic": "je", + "operands": "0x1400047f0" + } + ], + "successors": [ + "0x1400047f0", + "0x1400047e9" + ] + }, + { + "address": "0x1400047f0", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400047f0", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400047f4", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x1400047e9", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400047e9", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x1400047eb", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cda8" + }, + { + "address": "0x1400047f0", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400047f4", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400023d0", + "name": "", + "blocks": [ + { + "address": "0x1400023d0", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400023d0", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x48" + }, + { + "address": "0x1400023d4", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rcx" + }, + { + "address": "0x1400023d7", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x20]" + }, + { + "address": "0x1400023dc", + "size": 5, + "mnemonic": "call", + "operands": "0x140002344" + }, + { + "address": "0x1400023e1", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x2daf0]" + }, + { + "address": "0x1400023e8", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x20]" + }, + { + "address": "0x1400023ed", + "size": 5, + "mnemonic": "call", + "operands": "0x140006198" + }, + { + "address": "0x1400023f2", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140004770", + "name": "", + "blocks": [ + { + "address": "0x140004770", + "size": 16, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004770", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140004775", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140004776", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000477a", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdx" + }, + { + "address": "0x14000477d", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x140004780", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x140004782", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x140004784", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cda8" + }, + { + "address": "0x140004789", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000478c", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x1cced]" + }, + { + "address": "0x140004793", + "size": 4, + "mnemonic": "cmove", + "operands": "rax, rcx" + }, + { + "address": "0x140004797", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rdi + 0x48]" + }, + { + "address": "0x14000479b", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rax" + }, + { + "address": "0x14000479e", + "size": 5, + "mnemonic": "call", + "operands": "0x140004538" + }, + { + "address": "0x1400047a3", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x1400047a6", + "size": 2, + "mnemonic": "je", + "operands": "0x1400047b5" + } + ], + "successors": [ + "0x1400047b5", + "0x1400047a8" + ] + }, + { + "address": "0x1400047b5", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400047b5", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x1400047b8", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1cff1]" + }, + { + "address": "0x1400047bf", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rdi + 0x58]" + }, + { + "address": "0x1400047c3", + "size": 4, + "mnemonic": "cmove", + "operands": "rbx, rax" + }, + { + "address": "0x1400047c7", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x1400047ca", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x1400047cf", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400047d3", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400047d4", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140004538" + } + ], + "successors": [ + "0x140004538" + ] + }, + { + "address": "0x1400047a8", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400047a8", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x1400047ab", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x1400047ad", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cda8" + }, + { + "address": "0x1400047b2", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x1400047b5", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x1400047b8", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1cff1]" + }, + { + "address": "0x1400047bf", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rdi + 0x58]" + }, + { + "address": "0x1400047c3", + "size": 4, + "mnemonic": "cmove", + "operands": "rbx, rax" + }, + { + "address": "0x1400047c7", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x1400047ca", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x1400047cf", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400047d3", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400047d4", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140004538" + } + ], + "successors": [ + "0x140004538" + ] + }, + { + "address": "0x140004538", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004538", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000453d", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rsi" + }, + { + "address": "0x140004542", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140004543", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140004547", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x14000454a", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdx" + }, + { + "address": "0x14000454d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx]" + }, + { + "address": "0x140004550", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, rdx" + }, + { + "address": "0x140004553", + "size": 2, + "mnemonic": "je", + "operands": "0x1400045a0" + } + ], + "successors": [ + "0x1400045a0", + "0x140004555" + ] + }, + { + "address": "0x1400045a0", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400045a0", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x1400045a5", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdi" + }, + { + "address": "0x1400045a8", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x38]" + }, + { + "address": "0x1400045ad", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400045b1", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400045b2", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140004555", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004555", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140004558", + "size": 2, + "mnemonic": "je", + "operands": "0x14000455f" + } + ], + "successors": [ + "0x14000455f", + "0x14000455a" + ] + }, + { + "address": "0x14000455f", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000455f", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rdi], 0" + }, + { + "address": "0x140004566", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x140004569", + "size": 2, + "mnemonic": "je", + "operands": "0x1400045a0" + } + ], + "successors": [ + "0x1400045a0", + "0x14000456b" + ] + }, + { + "address": "0x14000455a", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000455a", + "size": 5, + "mnemonic": "call", + "operands": "0x14000c9d0" + }, + { + "address": "0x14000455f", + "size": 7, + "mnemonic": "mov", + "operands": "qword ptr [rdi], 0" + }, + { + "address": "0x140004566", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x140004569", + "size": 2, + "mnemonic": "je", + "operands": "0x1400045a0" + } + ], + "successors": [ + "0x1400045a0", + "0x14000456b" + ] + }, + { + "address": "0x14000456b", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000456b", + "size": 3, + "mnemonic": "cmp", + "operands": "byte ptr [rbx], 0" + }, + { + "address": "0x14000456e", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140004571", + "size": 2, + "mnemonic": "je", + "operands": "0x14000457b" + } + ], + "successors": [ + "0x14000457b", + "0x140004573" + ] + }, + { + "address": "0x14000457b", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000457b", + "size": 3, + "mnemonic": "sub", + "operands": "rax, rbx" + }, + { + "address": "0x14000457e", + "size": 4, + "mnemonic": "lea", + "operands": "rsi, [rax + 1]" + }, + { + "address": "0x140004582", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x140004585", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cac0" + }, + { + "address": "0x14000458a", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rdi], rax" + }, + { + "address": "0x14000458d", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140004590", + "size": 2, + "mnemonic": "je", + "operands": "0x1400045a0" + } + ], + "successors": [ + "0x1400045a0", + "0x140004592" + ] + }, + { + "address": "0x140004573", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004573", + "size": 3, + "mnemonic": "inc", + "operands": "rax" + }, + { + "address": "0x140004576", + "size": 3, + "mnemonic": "cmp", + "operands": "byte ptr [rax], 0" + }, + { + "address": "0x140004579", + "size": 2, + "mnemonic": "jne", + "operands": "0x140004573" + }, + { + "address": "0x14000457b", + "size": 3, + "mnemonic": "sub", + "operands": "rax, rbx" + }, + { + "address": "0x14000457e", + "size": 4, + "mnemonic": "lea", + "operands": "rsi, [rax + 1]" + }, + { + "address": "0x140004582", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x140004585", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cac0" + }, + { + "address": "0x14000458a", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rdi], rax" + }, + { + "address": "0x14000458d", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x140004590", + "size": 2, + "mnemonic": "je", + "operands": "0x1400045a0" + } + ], + "successors": [ + "0x1400045a0", + "0x140004592" + ] + }, + { + "address": "0x140004592", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140004592", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rsi" + }, + { + "address": "0x140004595", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x140004598", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x14000459b", + "size": 5, + "mnemonic": "call", + "operands": "0x14001e3e0" + }, + { + "address": "0x1400045a0", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x1400045a5", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdi" + }, + { + "address": "0x1400045a8", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x38]" + }, + { + "address": "0x1400045ad", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400045b1", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x1400045b2", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140002260", + "name": "", + "blocks": [ + { + "address": "0x140002260", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140002260", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1e321]" + }, + { + "address": "0x140002267", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 0x10], 0" + }, + { + "address": "0x14000226f", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 8], rax" + }, + { + "address": "0x140002273", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1e19e]" + }, + { + "address": "0x14000227a", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rcx], rax" + }, + { + "address": "0x14000227d", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rcx" + }, + { + "address": "0x140002280", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000d630", + "name": "", + "blocks": [ + { + "address": "0x14000d630", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d630", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140011a80" + } + ], + "successors": [ + "0x140011a80" + ] + } + ] + }, + { + "address": "0x14000d640", + "name": "", + "blocks": [ + { + "address": "0x14000d640", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d640", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000d645", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rsi" + }, + { + "address": "0x14000d64a", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000d64b", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000d64f", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x14000d652", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14000d655", + "size": 2, + "mnemonic": "je", + "operands": "0x14000d6a3" + } + ], + "successors": [ + "0x14000d6a3", + "0x14000d657" + ] + }, + { + "address": "0x14000d6a3", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000d6a3", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14000d6a8", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000d6aa", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14000d6af", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000d6b3", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000d6b4", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000d657", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000d657", + "size": 7, + "mnemonic": "mov", + "operands": "rbx, 0xffffffffffffffff" + }, + { + "address": "0x14000d65e", + "size": 2, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14000d660", + "size": 3, + "mnemonic": "inc", + "operands": "rbx" + }, + { + "address": "0x14000d663", + "size": 5, + "mnemonic": "cmp", + "operands": "word ptr [rcx + rbx*2], 0" + }, + { + "address": "0x14000d668", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000d660" + }, + { + "address": "0x14000d66a", + "size": 3, + "mnemonic": "inc", + "operands": "rbx" + }, + { + "address": "0x14000d66d", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbx + rbx]" + }, + { + "address": "0x14000d671", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cac0" + }, + { + "address": "0x14000d676", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rax" + }, + { + "address": "0x14000d679", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000d67c", + "size": 2, + "mnemonic": "je", + "operands": "0x14000d6a3" + } + ], + "successors": [ + "0x14000d6a3", + "0x14000d67e" + ] + }, + { + "address": "0x14000d67e", + "size": 12, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000d67e", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rdi" + }, + { + "address": "0x14000d681", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x14000d684", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x14000d687", + "size": 5, + "mnemonic": "call", + "operands": "0x1400165b0" + }, + { + "address": "0x14000d68c", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000d68e", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000d6b5" + }, + { + "address": "0x14000d690", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsi" + }, + { + "address": "0x14000d693", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14000d698", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14000d69d", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000d6a1", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000d6a2", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001a8ec", + "name": "", + "blocks": [ + { + "address": "0x14001a8ec", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a8ec", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14001a8f1", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001a8f2", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001a8f6", + "size": 5, + "mnemonic": "call", + "operands": "0x1400118c4" + }, + { + "address": "0x14001a8fb", + "size": 7, + "mnemonic": "lea", + "operands": "rdi, [rax + 0x90]" + }, + { + "address": "0x14001a902", + "size": 6, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rax + 0x3a8]" + }, + { + "address": "0x14001a908", + "size": 6, + "mnemonic": "mov", + "operands": "eax, dword ptr [rip + 0x16c82]" + }, + { + "address": "0x14001a90e", + "size": 2, + "mnemonic": "test", + "operands": "eax, ecx" + }, + { + "address": "0x14001a910", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a91a" + } + ], + "successors": [ + "0x14001a91a", + "0x14001a912" + ] + }, + { + "address": "0x14001a91a", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a91a", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 4" + }, + { + "address": "0x14001a91f", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca20" + }, + { + "address": "0x14001a924", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14001a925", + "size": 7, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rip + 0x1890c]" + }, + { + "address": "0x14001a92c", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x14001a92f", + "size": 5, + "mnemonic": "call", + "operands": "0x14001a95c" + }, + { + "address": "0x14001a934", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x14001a937", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 4" + }, + { + "address": "0x14001a93c", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca74" + }, + { + "address": "0x14001a941", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x14001a944", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a954" + } + ], + "successors": [ + "0x14001a954", + "0x14001a946" + ] + }, + { + "address": "0x14001a912", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a912", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rdi]" + }, + { + "address": "0x14001a915", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x14001a918", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001a946" + }, + { + "address": "0x14001a91a", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 4" + }, + { + "address": "0x14001a91f", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca20" + }, + { + "address": "0x14001a924", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14001a925", + "size": 7, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rip + 0x1890c]" + }, + { + "address": "0x14001a92c", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x14001a92f", + "size": 5, + "mnemonic": "call", + "operands": "0x14001a95c" + }, + { + "address": "0x14001a934", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x14001a937", + "size": 5, + "mnemonic": "mov", + "operands": "ecx, 4" + }, + { + "address": "0x14001a93c", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca74" + }, + { + "address": "0x14001a941", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x14001a944", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a954" + } + ], + "successors": [ + "0x14001a954", + "0x14001a946" + ] + }, + { + "address": "0x14001a954", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a954", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d6d0" + }, + { + "address": "0x14001a959", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14001a95a", + "size": 1, + "mnemonic": "int3", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001a946", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001a946", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x14001a949", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001a94e", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001a952", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001a953", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000df00", + "name": "", + "blocks": [ + { + "address": "0x14000df00", + "size": 17, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000df00", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x14000df02", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000df06", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14000df08", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca20" + }, + { + "address": "0x14000df0d", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14000df0e", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x2312b]" + }, + { + "address": "0x14000df15", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, eax" + }, + { + "address": "0x14000df17", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0x3f" + }, + { + "address": "0x14000df1a", + "size": 7, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rip + 0x25147]" + }, + { + "address": "0x14000df21", + "size": 3, + "mnemonic": "xor", + "operands": "rbx, rax" + }, + { + "address": "0x14000df24", + "size": 3, + "mnemonic": "ror", + "operands": "rbx, cl" + }, + { + "address": "0x14000df27", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14000df29", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca74" + }, + { + "address": "0x14000df2e", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x14000df31", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000df35", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000df36", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140016634", + "name": "", + "blocks": [ + { + "address": "0x140016634", + "size": 21, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140016634", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140016639", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r9" + }, + { + "address": "0x14001663e", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001663f", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140016643", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r9" + }, + { + "address": "0x140016646", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rdx]" + }, + { + "address": "0x140016648", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca20" + }, + { + "address": "0x14001664d", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14001664e", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x1a9eb]" + }, + { + "address": "0x140016655", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, eax" + }, + { + "address": "0x140016657", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0x3f" + }, + { + "address": "0x14001665a", + "size": 7, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rip + 0x1d0c7]" + }, + { + "address": "0x140016661", + "size": 3, + "mnemonic": "xor", + "operands": "rbx, rax" + }, + { + "address": "0x140016664", + "size": 3, + "mnemonic": "ror", + "operands": "rbx, cl" + }, + { + "address": "0x140016667", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rdi]" + }, + { + "address": "0x140016669", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca74" + }, + { + "address": "0x14001666e", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140016671", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140016676", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001667a", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001667b", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400117a4", + "name": "", + "blocks": [ + { + "address": "0x1400117a4", + "size": 16, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400117a4", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x1400117a9", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rsi" + }, + { + "address": "0x1400117ae", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x1400117af", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x1400117b3", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xe93f]" + }, + { + "address": "0x1400117b9", + "size": 6, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rip + 0x1fb01]" + }, + { + "address": "0x1400117bf", + "size": 4, + "mnemonic": "or", + "operands": "rdx, 0xffffffffffffffff" + }, + { + "address": "0x1400117c3", + "size": 2, + "mnemonic": "mov", + "operands": "edi, eax" + }, + { + "address": "0x1400117c5", + "size": 5, + "mnemonic": "call", + "operands": "0x140011fe8" + }, + { + "address": "0x1400117ca", + "size": 2, + "mnemonic": "xor", + "operands": "esi, esi" + }, + { + "address": "0x1400117cc", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x1400117ce", + "size": 2, + "mnemonic": "jne", + "operands": "0x1400117dc" + }, + { + "address": "0x1400117d0", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, edi" + }, + { + "address": "0x1400117d2", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0xe928]" + }, + { + "address": "0x1400117d8", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x1400117da", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140011849" + } + ], + "successors": [ + "0x140011849" + ] + }, + { + "address": "0x140011849", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140011849", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001184e", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x38]" + }, + { + "address": "0x140011853", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140011857", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140011858", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000b1f8", + "name": "", + "blocks": [ + { + "address": "0x14000b1f8", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b1f8", + "size": 4, + "mnemonic": "add", + "operands": "rcx, 0x30" + }, + { + "address": "0x14000b1fc", + "size": 7, + "mnemonic": "jmp", + "operands": "qword ptr [rip + 0x14e0d]" + } + ], + "successors": [ + "0x140020010" + ] + } + ] + }, + { + "address": "0x14000b678", + "name": "", + "blocks": [ + { + "address": "0x14000b678", + "size": 22, + "is_prolog": true, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000b678", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000b67d", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rdi" + }, + { + "address": "0x14000b682", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000b683", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14000b686", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x60" + }, + { + "address": "0x14000b68a", + "size": 5, + "mnemonic": "and", + "operands": "qword ptr [rbp - 0x40], 0" + }, + { + "address": "0x14000b68f", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14000b692", + "size": 7, + "mnemonic": "cmp", + "operands": "dword ptr [rip + 0x27b57], 0" + }, + { + "address": "0x14000b699", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x30], 0" + }, + { + "address": "0x14000b69d", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 0" + }, + { + "address": "0x14000b6a1", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x10], 0" + }, + { + "address": "0x14000b6a5", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 8], 0" + }, + { + "address": "0x14000b6a9", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000b6bb" + }, + { + "address": "0x14000b6ab", + "size": 7, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [rip + 0x25d76]" + }, + { + "address": "0x14000b6b2", + "size": 4, + "mnemonic": "mov", + "operands": "byte ptr [rbp - 0x18], 1" + }, + { + "address": "0x14000b6b6", + "size": 5, + "mnemonic": "movdqu", + "operands": "xmmword ptr [rbp - 0x28], xmm0" + }, + { + "address": "0x14000b6bb", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x14000b6be", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000b6cb" + }, + { + "address": "0x14000b6c0", + "size": 2, + "mnemonic": "xor", + "operands": "ecx, ecx" + }, + { + "address": "0x14000b6c2", + "size": 5, + "mnemonic": "call", + "operands": "0x14000b58c" + }, + { + "address": "0x14000b6c7", + "size": 2, + "mnemonic": "mov", + "operands": "edi, eax" + }, + { + "address": "0x14000b6c9", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000b6fd" + } + ], + "successors": [ + "0x14000b6fd" + ] + } + ] + }, + { + "address": "0x14001be60", + "name": "", + "blocks": [ + { + "address": "0x14001be60", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001be60", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14001be65", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x14001be6a", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x14001be6f", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001be70", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001be74", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, r8" + }, + { + "address": "0x14001be77", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdx" + }, + { + "address": "0x14001be7a", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rcx" + }, + { + "address": "0x14001be7d", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14001be80", + "size": 2, + "mnemonic": "je", + "operands": "0x14001be9f" + } + ], + "successors": [ + "0x14001be9f", + "0x14001be82" + ] + }, + { + "address": "0x14001be9f", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001be9f", + "size": 3, + "mnemonic": "test", + "operands": "rsi, rsi" + }, + { + "address": "0x14001bea2", + "size": 2, + "mnemonic": "je", + "operands": "0x14001beae" + } + ], + "successors": [ + "0x14001beae", + "0x14001bea4" + ] + }, + { + "address": "0x14001be82", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001be82", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14001be84", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rdx - 0x20]" + }, + { + "address": "0x14001be88", + "size": 3, + "mnemonic": "div", + "operands": "rbx" + }, + { + "address": "0x14001be8b", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, r8" + }, + { + "address": "0x14001be8e", + "size": 2, + "mnemonic": "jae", + "operands": "0x14001be9f" + }, + { + "address": "0x14001be90", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x14001be95", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0xc" + }, + { + "address": "0x14001be9b", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001be9d", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001bee0" + } + ], + "successors": [ + "0x14001bee0" + ] + }, + { + "address": "0x14001beae", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001beae", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x14001beb0", + "size": 4, + "mnemonic": "imul", + "operands": "rbx, rbp" + }, + { + "address": "0x14001beb4", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x14001beb7", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x14001beba", + "size": 5, + "mnemonic": "call", + "operands": "0x140016930" + }, + { + "address": "0x14001bebf", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rax" + }, + { + "address": "0x14001bec2", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001bec5", + "size": 2, + "mnemonic": "je", + "operands": "0x14001bedd" + } + ], + "successors": [ + "0x14001bedd", + "0x14001bec7" + ] + }, + { + "address": "0x14001bea4", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001bea4", + "size": 5, + "mnemonic": "call", + "operands": "0x14001d6d0" + }, + { + "address": "0x14001bea9", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rax" + }, + { + "address": "0x14001beac", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001beb0" + } + ], + "successors": [ + "0x14001beb0" + ] + }, + { + "address": "0x14001bee0", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001bee0", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001bee5", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14001beea", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14001beef", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001bef3", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001bef4", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001bedd", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001bedd", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsi" + }, + { + "address": "0x14001bee0", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001bee5", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14001beea", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14001beef", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001bef3", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001bef4", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001bec7", + "size": 14, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001bec7", + "size": 3, + "mnemonic": "cmp", + "operands": "rdi, rbx" + }, + { + "address": "0x14001beca", + "size": 2, + "mnemonic": "jae", + "operands": "0x14001bedd" + }, + { + "address": "0x14001becc", + "size": 3, + "mnemonic": "sub", + "operands": "rbx, rdi" + }, + { + "address": "0x14001becf", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rax + rdi]" + }, + { + "address": "0x14001bed3", + "size": 3, + "mnemonic": "mov", + "operands": "r8, rbx" + }, + { + "address": "0x14001bed6", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14001bed8", + "size": 5, + "mnemonic": "call", + "operands": "0x14001ea80" + }, + { + "address": "0x14001bedd", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsi" + }, + { + "address": "0x14001bee0", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001bee5", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14001beea", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14001beef", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001bef3", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001bef4", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001beb0", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001beb0", + "size": 4, + "mnemonic": "imul", + "operands": "rbx, rbp" + }, + { + "address": "0x14001beb4", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rsi" + }, + { + "address": "0x14001beb7", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rbx" + }, + { + "address": "0x14001beba", + "size": 5, + "mnemonic": "call", + "operands": "0x140016930" + }, + { + "address": "0x14001bebf", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rax" + }, + { + "address": "0x14001bec2", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001bec5", + "size": 2, + "mnemonic": "je", + "operands": "0x14001bedd" + } + ], + "successors": [ + "0x14001bedd", + "0x14001bec7" + ] + } + ] + }, + { + "address": "0x14001a844", + "name": "", + "blocks": [ + { + "address": "0x14001a844", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a844", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x14001a848", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001a84b", + "size": 6, + "mnemonic": "je", + "operands": "0x14001a8e7" + } + ], + "successors": [ + "0x14001a8e7", + "0x14001a851" + ] + }, + { + "address": "0x14001a8e7", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001a8e7", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14001a8eb", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001a851", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a851", + "size": 4, + "mnemonic": "or", + "operands": "r9d, 0xffffffff" + }, + { + "address": "0x14001a855", + "size": 5, + "mnemonic": "lock add", + "operands": "dword ptr [rcx + 0x10], r9d" + }, + { + "address": "0x14001a85a", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0xe0]" + }, + { + "address": "0x14001a861", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001a864", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a86a" + } + ], + "successors": [ + "0x14001a86a", + "0x14001a866" + ] + }, + { + "address": "0x14001a86a", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a86a", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0xf0]" + }, + { + "address": "0x14001a871", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001a874", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a87a" + } + ], + "successors": [ + "0x14001a87a", + "0x14001a876" + ] + }, + { + "address": "0x14001a866", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a866", + "size": 4, + "mnemonic": "lock add", + "operands": "dword ptr [rax], r9d" + }, + { + "address": "0x14001a86a", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0xf0]" + }, + { + "address": "0x14001a871", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001a874", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a87a" + } + ], + "successors": [ + "0x14001a87a", + "0x14001a876" + ] + }, + { + "address": "0x14001a87a", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a87a", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0xe8]" + }, + { + "address": "0x14001a881", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001a884", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a88a" + } + ], + "successors": [ + "0x14001a88a", + "0x14001a886" + ] + }, + { + "address": "0x14001a876", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a876", + "size": 4, + "mnemonic": "lock add", + "operands": "dword ptr [rax], r9d" + }, + { + "address": "0x14001a87a", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0xe8]" + }, + { + "address": "0x14001a881", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001a884", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a88a" + } + ], + "successors": [ + "0x14001a88a", + "0x14001a886" + ] + }, + { + "address": "0x14001a88a", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a88a", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0x100]" + }, + { + "address": "0x14001a891", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001a894", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a89a" + } + ], + "successors": [ + "0x14001a89a", + "0x14001a896" + ] + }, + { + "address": "0x14001a886", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a886", + "size": 4, + "mnemonic": "lock add", + "operands": "dword ptr [rax], r9d" + }, + { + "address": "0x14001a88a", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0x100]" + }, + { + "address": "0x14001a891", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001a894", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a89a" + } + ], + "successors": [ + "0x14001a89a", + "0x14001a896" + ] + }, + { + "address": "0x14001a89a", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a89a", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rcx + 0x38]" + }, + { + "address": "0x14001a89e", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 6" + }, + { + "address": "0x14001a8a4", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x16b8d]" + }, + { + "address": "0x14001a8ab", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [rax - 0x10], rdx" + }, + { + "address": "0x14001a8af", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a8bd" + } + ], + "successors": [ + "0x14001a8bd", + "0x14001a8b1" + ] + }, + { + "address": "0x14001a896", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a896", + "size": 4, + "mnemonic": "lock add", + "operands": "dword ptr [rax], r9d" + }, + { + "address": "0x14001a89a", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rcx + 0x38]" + }, + { + "address": "0x14001a89e", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 6" + }, + { + "address": "0x14001a8a4", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x16b8d]" + }, + { + "address": "0x14001a8ab", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [rax - 0x10], rdx" + }, + { + "address": "0x14001a8af", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a8bd" + } + ], + "successors": [ + "0x14001a8bd", + "0x14001a8b1" + ] + }, + { + "address": "0x14001a8bd", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a8bd", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rax - 0x18], 0" + }, + { + "address": "0x14001a8c2", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a8d1" + } + ], + "successors": [ + "0x14001a8d1", + "0x14001a8c4" + ] + }, + { + "address": "0x14001a8b1", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a8b1", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rax]" + }, + { + "address": "0x14001a8b4", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14001a8b7", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a8bd" + } + ], + "successors": [ + "0x14001a8bd", + "0x14001a8b9" + ] + }, + { + "address": "0x14001a8d1", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001a8d1", + "size": 4, + "mnemonic": "add", + "operands": "rax, 0x20" + }, + { + "address": "0x14001a8d5", + "size": 4, + "mnemonic": "sub", + "operands": "r8, 1" + }, + { + "address": "0x14001a8d9", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001a8a4" + }, + { + "address": "0x14001a8db", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x120]" + }, + { + "address": "0x14001a8e2", + "size": 5, + "mnemonic": "call", + "operands": "0x14001a81c" + }, + { + "address": "0x14001a8e7", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14001a8eb", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001a8c4", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a8c4", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rax - 8]" + }, + { + "address": "0x14001a8c8", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14001a8cb", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a8d1" + } + ], + "successors": [ + "0x14001a8d1", + "0x14001a8cd" + ] + }, + { + "address": "0x14001a8b9", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a8b9", + "size": 4, + "mnemonic": "lock add", + "operands": "dword ptr [rdx], r9d" + }, + { + "address": "0x14001a8bd", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rax - 0x18], 0" + }, + { + "address": "0x14001a8c2", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a8d1" + } + ], + "successors": [ + "0x14001a8d1", + "0x14001a8c4" + ] + }, + { + "address": "0x14001a8cd", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001a8cd", + "size": 4, + "mnemonic": "lock add", + "operands": "dword ptr [rdx], r9d" + }, + { + "address": "0x14001a8d1", + "size": 4, + "mnemonic": "add", + "operands": "rax, 0x20" + }, + { + "address": "0x14001a8d5", + "size": 4, + "mnemonic": "sub", + "operands": "r8, 1" + }, + { + "address": "0x14001a8d9", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001a8a4" + }, + { + "address": "0x14001a8db", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x120]" + }, + { + "address": "0x14001a8e2", + "size": 5, + "mnemonic": "call", + "operands": "0x14001a81c" + }, + { + "address": "0x14001a8e7", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14001a8eb", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001a5b8", + "name": "", + "blocks": [ + { + "address": "0x14001a5b8", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a5b8", + "size": 4, + "mnemonic": "lock inc", + "operands": "dword ptr [rcx + 0x10]" + }, + { + "address": "0x14001a5bc", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0xe0]" + }, + { + "address": "0x14001a5c3", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001a5c6", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a5cb" + } + ], + "successors": [ + "0x14001a5cb", + "0x14001a5c8" + ] + }, + { + "address": "0x14001a5cb", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a5cb", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0xf0]" + }, + { + "address": "0x14001a5d2", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001a5d5", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a5da" + } + ], + "successors": [ + "0x14001a5da", + "0x14001a5d7" + ] + }, + { + "address": "0x14001a5c8", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a5c8", + "size": 3, + "mnemonic": "lock inc", + "operands": "dword ptr [rax]" + }, + { + "address": "0x14001a5cb", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0xf0]" + }, + { + "address": "0x14001a5d2", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001a5d5", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a5da" + } + ], + "successors": [ + "0x14001a5da", + "0x14001a5d7" + ] + }, + { + "address": "0x14001a5da", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a5da", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0xe8]" + }, + { + "address": "0x14001a5e1", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001a5e4", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a5e9" + } + ], + "successors": [ + "0x14001a5e9", + "0x14001a5e6" + ] + }, + { + "address": "0x14001a5d7", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a5d7", + "size": 3, + "mnemonic": "lock inc", + "operands": "dword ptr [rax]" + }, + { + "address": "0x14001a5da", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0xe8]" + }, + { + "address": "0x14001a5e1", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001a5e4", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a5e9" + } + ], + "successors": [ + "0x14001a5e9", + "0x14001a5e6" + ] + }, + { + "address": "0x14001a5e9", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a5e9", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0x100]" + }, + { + "address": "0x14001a5f0", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001a5f3", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a5f8" + } + ], + "successors": [ + "0x14001a5f8", + "0x14001a5f5" + ] + }, + { + "address": "0x14001a5e6", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a5e6", + "size": 3, + "mnemonic": "lock inc", + "operands": "dword ptr [rax]" + }, + { + "address": "0x14001a5e9", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0x100]" + }, + { + "address": "0x14001a5f0", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001a5f3", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a5f8" + } + ], + "successors": [ + "0x14001a5f8", + "0x14001a5f5" + ] + }, + { + "address": "0x14001a5f8", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a5f8", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rcx + 0x38]" + }, + { + "address": "0x14001a5fc", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 6" + }, + { + "address": "0x14001a602", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x16e2f]" + }, + { + "address": "0x14001a609", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [rax - 0x10], rdx" + }, + { + "address": "0x14001a60d", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a61a" + } + ], + "successors": [ + "0x14001a61a", + "0x14001a60f" + ] + }, + { + "address": "0x14001a5f5", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a5f5", + "size": 3, + "mnemonic": "lock inc", + "operands": "dword ptr [rax]" + }, + { + "address": "0x14001a5f8", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rcx + 0x38]" + }, + { + "address": "0x14001a5fc", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 6" + }, + { + "address": "0x14001a602", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x16e2f]" + }, + { + "address": "0x14001a609", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [rax - 0x10], rdx" + }, + { + "address": "0x14001a60d", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a61a" + } + ], + "successors": [ + "0x14001a61a", + "0x14001a60f" + ] + }, + { + "address": "0x14001a61a", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a61a", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rax - 0x18], 0" + }, + { + "address": "0x14001a61f", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a62d" + } + ], + "successors": [ + "0x14001a62d", + "0x14001a621" + ] + }, + { + "address": "0x14001a60f", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a60f", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rax]" + }, + { + "address": "0x14001a612", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14001a615", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a61a" + } + ], + "successors": [ + "0x14001a61a", + "0x14001a617" + ] + }, + { + "address": "0x14001a62d", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a62d", + "size": 4, + "mnemonic": "add", + "operands": "rax, 0x20" + }, + { + "address": "0x14001a631", + "size": 4, + "mnemonic": "sub", + "operands": "r8, 1" + }, + { + "address": "0x14001a635", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001a602" + }, + { + "address": "0x14001a637", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x120]" + }, + { + "address": "0x14001a63e", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14001a7bc" + } + ], + "successors": [ + "0x14001a7bc" + ] + }, + { + "address": "0x14001a621", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a621", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rax - 8]" + }, + { + "address": "0x14001a625", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14001a628", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a62d" + } + ], + "successors": [ + "0x14001a62d", + "0x14001a62a" + ] + }, + { + "address": "0x14001a617", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a617", + "size": 3, + "mnemonic": "lock inc", + "operands": "dword ptr [rdx]" + }, + { + "address": "0x14001a61a", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rax - 0x18], 0" + }, + { + "address": "0x14001a61f", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a62d" + } + ], + "successors": [ + "0x14001a62d", + "0x14001a621" + ] + }, + { + "address": "0x14001a7bc", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a7bc", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001a7bf", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a7dd" + } + ], + "successors": [ + "0x14001a7dd", + "0x14001a7c1" + ] + }, + { + "address": "0x14001a62a", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a62a", + "size": 3, + "mnemonic": "lock inc", + "operands": "dword ptr [rdx]" + }, + { + "address": "0x14001a62d", + "size": 4, + "mnemonic": "add", + "operands": "rax, 0x20" + }, + { + "address": "0x14001a631", + "size": 4, + "mnemonic": "sub", + "operands": "r8, 1" + }, + { + "address": "0x14001a635", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001a602" + }, + { + "address": "0x14001a637", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x120]" + }, + { + "address": "0x14001a63e", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14001a7bc" + } + ], + "successors": [ + "0x14001a7bc" + ] + }, + { + "address": "0x14001a7dd", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001a7dd", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x7fffffff" + }, + { + "address": "0x14001a7e2", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001a7c1", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a7c1", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0xb458]" + }, + { + "address": "0x14001a7c8", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, rax" + }, + { + "address": "0x14001a7cb", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a7dd" + } + ], + "successors": [ + "0x14001a7dd", + "0x14001a7cd" + ] + }, + { + "address": "0x14001a7cd", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001a7cd", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 1" + }, + { + "address": "0x14001a7d2", + "size": 8, + "mnemonic": "lock xadd", + "operands": "dword ptr [rcx + 0x15c], eax" + }, + { + "address": "0x14001a7da", + "size": 2, + "mnemonic": "inc", + "operands": "eax" + }, + { + "address": "0x14001a7dc", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001a644", + "name": "", + "blocks": [ + { + "address": "0x14001a644", + "size": 9, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a644", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14001a649", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x14001a64e", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x14001a653", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001a654", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001a658", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 0xf8]" + }, + { + "address": "0x14001a65f", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14001a662", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001a665", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a6e0" + } + ], + "successors": [ + "0x14001a6e0", + "0x14001a667" + ] + }, + { + "address": "0x14001a6e0", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a6e0", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx + 0x100]" + }, + { + "address": "0x14001a6e7", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001a6ea", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a733" + } + ], + "successors": [ + "0x14001a733", + "0x14001a6ec" + ] + }, + { + "address": "0x14001a667", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a667", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x16b92]" + }, + { + "address": "0x14001a66e", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, rcx" + }, + { + "address": "0x14001a671", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a6e0" + } + ], + "successors": [ + "0x14001a6e0", + "0x14001a673" + ] + }, + { + "address": "0x14001a733", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a733", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x120]" + }, + { + "address": "0x14001a73a", + "size": 5, + "mnemonic": "call", + "operands": "0x14001a7e4" + }, + { + "address": "0x14001a73f", + "size": 7, + "mnemonic": "lea", + "operands": "rsi, [rbx + 0x128]" + }, + { + "address": "0x14001a746", + "size": 5, + "mnemonic": "mov", + "operands": "ebp, 6" + }, + { + "address": "0x14001a74b", + "size": 4, + "mnemonic": "lea", + "operands": "rdi, [rbx + 0x38]" + }, + { + "address": "0x14001a74f", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x16ce2]" + }, + { + "address": "0x14001a756", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [rdi - 0x10], rax" + }, + { + "address": "0x14001a75a", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a776" + } + ], + "successors": [ + "0x14001a776", + "0x14001a75c" + ] + }, + { + "address": "0x14001a6ec", + "size": 22, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a6ec", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rax], 0" + }, + { + "address": "0x14001a6ef", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001a733" + }, + { + "address": "0x14001a6f1", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x108]" + }, + { + "address": "0x14001a6f8", + "size": 7, + "mnemonic": "sub", + "operands": "rcx, 0xfe" + }, + { + "address": "0x14001a6ff", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001a704", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x110]" + }, + { + "address": "0x14001a70b", + "size": 5, + "mnemonic": "mov", + "operands": "edi, 0x80" + }, + { + "address": "0x14001a710", + "size": 3, + "mnemonic": "sub", + "operands": "rcx, rdi" + }, + { + "address": "0x14001a713", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001a718", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x118]" + }, + { + "address": "0x14001a71f", + "size": 3, + "mnemonic": "sub", + "operands": "rcx, rdi" + }, + { + "address": "0x14001a722", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001a727", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x100]" + }, + { + "address": "0x14001a72e", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001a733", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x120]" + }, + { + "address": "0x14001a73a", + "size": 5, + "mnemonic": "call", + "operands": "0x14001a7e4" + }, + { + "address": "0x14001a73f", + "size": 7, + "mnemonic": "lea", + "operands": "rsi, [rbx + 0x128]" + }, + { + "address": "0x14001a746", + "size": 5, + "mnemonic": "mov", + "operands": "ebp, 6" + }, + { + "address": "0x14001a74b", + "size": 4, + "mnemonic": "lea", + "operands": "rdi, [rbx + 0x38]" + }, + { + "address": "0x14001a74f", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x16ce2]" + }, + { + "address": "0x14001a756", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [rdi - 0x10], rax" + }, + { + "address": "0x14001a75a", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a776" + } + ], + "successors": [ + "0x14001a776", + "0x14001a75c" + ] + }, + { + "address": "0x14001a673", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a673", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx + 0xe0]" + }, + { + "address": "0x14001a67a", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001a67d", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a6e0" + } + ], + "successors": [ + "0x14001a6e0", + "0x14001a67f" + ] + }, + { + "address": "0x14001a776", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a776", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rdi - 0x18], 0" + }, + { + "address": "0x14001a77b", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a790" + } + ], + "successors": [ + "0x14001a790", + "0x14001a77d" + ] + }, + { + "address": "0x14001a75c", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a75c", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdi]" + }, + { + "address": "0x14001a75f", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001a762", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a776" + } + ], + "successors": [ + "0x14001a776", + "0x14001a764" + ] + }, + { + "address": "0x14001a67f", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a67f", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rax], 0" + }, + { + "address": "0x14001a682", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001a6e0" + }, + { + "address": "0x14001a684", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0xf0]" + }, + { + "address": "0x14001a68b", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001a68e", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a6a6" + } + ], + "successors": [ + "0x14001a6a6", + "0x14001a690" + ] + }, + { + "address": "0x14001a790", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a790", + "size": 4, + "mnemonic": "add", + "operands": "rsi, 8" + }, + { + "address": "0x14001a794", + "size": 4, + "mnemonic": "add", + "operands": "rdi, 0x20" + }, + { + "address": "0x14001a798", + "size": 4, + "mnemonic": "sub", + "operands": "rbp, 1" + }, + { + "address": "0x14001a79c", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001a74f" + }, + { + "address": "0x14001a79e", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x14001a7a1", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001a7a6", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14001a7ab", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14001a7b0", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001a7b4", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001a7b5", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140011b00" + } + ], + "successors": [ + "0x140011b00" + ] + }, + { + "address": "0x14001a77d", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a77d", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdi - 8]" + }, + { + "address": "0x14001a781", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001a784", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a790" + } + ], + "successors": [ + "0x14001a790", + "0x14001a786" + ] + }, + { + "address": "0x14001a764", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a764", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rcx], 0" + }, + { + "address": "0x14001a767", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001a776" + }, + { + "address": "0x14001a769", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001a76e", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsi]" + }, + { + "address": "0x14001a771", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001a776", + "size": 5, + "mnemonic": "cmp", + "operands": "qword ptr [rdi - 0x18], 0" + }, + { + "address": "0x14001a77b", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a790" + } + ], + "successors": [ + "0x14001a790", + "0x14001a77d" + ] + }, + { + "address": "0x14001a6a6", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a6a6", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0xe8]" + }, + { + "address": "0x14001a6ad", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001a6b0", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a6c8" + } + ], + "successors": [ + "0x14001a6c8", + "0x14001a6b2" + ] + }, + { + "address": "0x14001a690", + "size": 8, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a690", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rcx], 0" + }, + { + "address": "0x14001a693", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001a6a6" + }, + { + "address": "0x14001a695", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001a69a", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0xf8]" + }, + { + "address": "0x14001a6a1", + "size": 5, + "mnemonic": "call", + "operands": "0x14001952c" + }, + { + "address": "0x14001a6a6", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0xe8]" + }, + { + "address": "0x14001a6ad", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001a6b0", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a6c8" + } + ], + "successors": [ + "0x14001a6c8", + "0x14001a6b2" + ] + }, + { + "address": "0x14001a786", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a786", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rcx], 0" + }, + { + "address": "0x14001a789", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001a790" + }, + { + "address": "0x14001a78b", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001a790", + "size": 4, + "mnemonic": "add", + "operands": "rsi, 8" + }, + { + "address": "0x14001a794", + "size": 4, + "mnemonic": "add", + "operands": "rdi, 0x20" + }, + { + "address": "0x14001a798", + "size": 4, + "mnemonic": "sub", + "operands": "rbp, 1" + }, + { + "address": "0x14001a79c", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001a74f" + }, + { + "address": "0x14001a79e", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x14001a7a1", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001a7a6", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14001a7ab", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14001a7b0", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001a7b4", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001a7b5", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140011b00" + } + ], + "successors": [ + "0x140011b00" + ] + }, + { + "address": "0x14001a6c8", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a6c8", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0xe0]" + }, + { + "address": "0x14001a6cf", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001a6d4", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0xf8]" + }, + { + "address": "0x14001a6db", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001a6e0", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx + 0x100]" + }, + { + "address": "0x14001a6e7", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001a6ea", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a733" + } + ], + "successors": [ + "0x14001a733", + "0x14001a6ec" + ] + }, + { + "address": "0x14001a6b2", + "size": 12, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a6b2", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rcx], 0" + }, + { + "address": "0x14001a6b5", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001a6c8" + }, + { + "address": "0x14001a6b7", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001a6bc", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0xf8]" + }, + { + "address": "0x14001a6c3", + "size": 5, + "mnemonic": "call", + "operands": "0x140019b54" + }, + { + "address": "0x14001a6c8", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0xe0]" + }, + { + "address": "0x14001a6cf", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001a6d4", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0xf8]" + }, + { + "address": "0x14001a6db", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001a6e0", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rbx + 0x100]" + }, + { + "address": "0x14001a6e7", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14001a6ea", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a733" + } + ], + "successors": [ + "0x14001a733", + "0x14001a6ec" + ] + } + ] + }, + { + "address": "0x1400188c8", + "name": "", + "blocks": [ + { + "address": "0x1400188c8", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400188c8", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400188cc", + "size": 5, + "mnemonic": "call", + "operands": "0x1400118c4" + }, + { + "address": "0x1400188d1", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x1af68]" + }, + { + "address": "0x1400188d8", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x1400188db", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x1400188df", + "size": 5, + "mnemonic": "jmp", + "operands": "0x1400187b0" + } + ], + "successors": [ + "0x1400187b0" + ] + } + ] + }, + { + "address": "0x14001c11c", + "name": "", + "blocks": [ + { + "address": "0x14001c11c", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c11c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14001c121", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x14001c126", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x14001c12b", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001c12c", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14001c12e", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14001c130", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001c134", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x14001c137", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001c13a", + "size": 2, + "mnemonic": "je", + "operands": "0x14001c187" + } + ], + "successors": [ + "0x14001c187", + "0x14001c13c" + ] + }, + { + "address": "0x14001c187", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001c187", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001c189", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14001c18e", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14001c193", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14001c198", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001c19c", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14001c19e", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001c1a0", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001c1a1", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001c13c", + "size": 16, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c13c", + "size": 2, + "mnemonic": "xor", + "operands": "ebx, ebx" + }, + { + "address": "0x14001c13e", + "size": 7, + "mnemonic": "lea", + "operands": "r15, [rip - 0x1c145]" + }, + { + "address": "0x14001c145", + "size": 5, + "mnemonic": "mov", + "operands": "esi, 0xe3" + }, + { + "address": "0x14001c14a", + "size": 3, + "mnemonic": "lea", + "operands": "eax, [rsi + rbx]" + }, + { + "address": "0x14001c14d", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x55" + }, + { + "address": "0x14001c153", + "size": 1, + "mnemonic": "cdq", + "operands": "" + }, + { + "address": "0x14001c154", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x14001c157", + "size": 2, + "mnemonic": "sub", + "operands": "eax, edx" + }, + { + "address": "0x14001c159", + "size": 2, + "mnemonic": "sar", + "operands": "eax, 1" + }, + { + "address": "0x14001c15b", + "size": 3, + "mnemonic": "movsxd", + "operands": "rbp, eax" + }, + { + "address": "0x14001c15e", + "size": 3, + "mnemonic": "mov", + "operands": "r14, rbp" + }, + { + "address": "0x14001c161", + "size": 3, + "mnemonic": "add", + "operands": "r14, r14" + }, + { + "address": "0x14001c164", + "size": 8, + "mnemonic": "mov", + "operands": "rdx, qword ptr [r15 + r14*8 + 0x294f0]" + }, + { + "address": "0x14001c16c", + "size": 5, + "mnemonic": "call", + "operands": "0x14001d410" + }, + { + "address": "0x14001c171", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001c173", + "size": 2, + "mnemonic": "je", + "operands": "0x14001c1a2" + } + ], + "successors": [ + "0x14001c1a2", + "0x14001c175" + ] + }, + { + "address": "0x14001c1a2", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c1a2", + "size": 8, + "mnemonic": "movsxd", + "operands": "rax, dword ptr [r15 + r14*8 + 0x294f8]" + }, + { + "address": "0x14001c1aa", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001c1ac", + "size": 2, + "mnemonic": "js", + "operands": "0x14001c187" + } + ], + "successors": [ + "0x14001c187", + "0x14001c1ae" + ] + }, + { + "address": "0x14001c175", + "size": 16, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001c175", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rbp - 1]" + }, + { + "address": "0x14001c178", + "size": 3, + "mnemonic": "cmovns", + "operands": "ecx, esi" + }, + { + "address": "0x14001c17b", + "size": 2, + "mnemonic": "mov", + "operands": "esi, ecx" + }, + { + "address": "0x14001c17d", + "size": 3, + "mnemonic": "lea", + "operands": "ecx, [rbp + 1]" + }, + { + "address": "0x14001c180", + "size": 3, + "mnemonic": "cmovns", + "operands": "ebx, ecx" + }, + { + "address": "0x14001c183", + "size": 2, + "mnemonic": "cmp", + "operands": "ebx, esi" + }, + { + "address": "0x14001c185", + "size": 2, + "mnemonic": "jle", + "operands": "0x14001c14a" + }, + { + "address": "0x14001c187", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001c189", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14001c18e", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14001c193", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14001c198", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001c19c", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14001c19e", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001c1a0", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001c1a1", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001c1ae", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001c1ae", + "size": 6, + "mnemonic": "cmp", + "operands": "rax, 0xe4" + }, + { + "address": "0x14001c1b4", + "size": 2, + "mnemonic": "jae", + "operands": "0x14001c187" + }, + { + "address": "0x14001c1b6", + "size": 3, + "mnemonic": "add", + "operands": "rax, rax" + }, + { + "address": "0x14001c1b9", + "size": 8, + "mnemonic": "mov", + "operands": "eax, dword ptr [r15 + rax*8 + 0x27aa0]" + }, + { + "address": "0x14001c1c1", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001c189" + } + ], + "successors": [ + "0x14001c189" + ] + }, + { + "address": "0x14001c189", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001c189", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14001c18e", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14001c193", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14001c198", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001c19c", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14001c19e", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001c1a0", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001c1a1", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140004d34", + "name": "", + "blocks": [ + { + "address": "0x140004d34", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004d34", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140004d39", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140004d3a", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140004d3e", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x140004d41", + "size": 4, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rcx + 0x38]" + }, + { + "address": "0x140004d45", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140004d5d" + } + ], + "successors": [ + "0x140004d5d" + ] + }, + { + "address": "0x140004d5d", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004d5d", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x140004d60", + "size": 2, + "mnemonic": "jne", + "operands": "0x140004d47" + }, + { + "address": "0x140004d62", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdi + 0x30]" + }, + { + "address": "0x140004d66", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140004d69", + "size": 2, + "mnemonic": "je", + "operands": "0x140004d80" + } + ], + "successors": [ + "0x140004d80", + "0x140004d6b" + ] + }, + { + "address": "0x140004d80", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004d80", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rdi + 0x30], 0" + }, + { + "address": "0x140004d88", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdi + 0x38]" + }, + { + "address": "0x140004d8c", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140004d8f", + "size": 2, + "mnemonic": "je", + "operands": "0x140004da6" + } + ], + "successors": [ + "0x140004da6", + "0x140004d91" + ] + }, + { + "address": "0x140004d6b", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140004d6b", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rcx]" + }, + { + "address": "0x140004d6e", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0x18" + }, + { + "address": "0x140004d73", + "size": 5, + "mnemonic": "call", + "operands": "0x140005170" + }, + { + "address": "0x140004d78", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140004d7b", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x140004d7e", + "size": 2, + "mnemonic": "jne", + "operands": "0x140004d6b" + }, + { + "address": "0x140004d80", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rdi + 0x30], 0" + }, + { + "address": "0x140004d88", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rdi + 0x38]" + }, + { + "address": "0x140004d8c", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140004d8f", + "size": 2, + "mnemonic": "je", + "operands": "0x140004da6" + } + ], + "successors": [ + "0x140004da6", + "0x140004d91" + ] + }, + { + "address": "0x140004da6", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140004da6", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rdi + 0x38], 0" + }, + { + "address": "0x140004dae", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140004db3", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140004db7", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140004db8", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140004d91", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140004d91", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rcx]" + }, + { + "address": "0x140004d94", + "size": 5, + "mnemonic": "mov", + "operands": "edx, 0x18" + }, + { + "address": "0x140004d99", + "size": 5, + "mnemonic": "call", + "operands": "0x140005170" + }, + { + "address": "0x140004d9e", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140004da1", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x140004da4", + "size": 2, + "mnemonic": "jne", + "operands": "0x140004d91" + }, + { + "address": "0x140004da6", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rdi + 0x38], 0" + }, + { + "address": "0x140004dae", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140004db3", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140004db7", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140004db8", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000753c", + "name": "", + "blocks": [ + { + "address": "0x14000753c", + "size": 12, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000753c", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x140007540", + "size": 4, + "mnemonic": "movsxd", + "operands": "r9, dword ptr [r8 + 0x1c]" + }, + { + "address": "0x140007544", + "size": 3, + "mnemonic": "mov", + "operands": "r10, r8" + }, + { + "address": "0x140007547", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x14000754a", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r9 + rax]" + }, + { + "address": "0x14000754e", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, -2" + }, + { + "address": "0x140007551", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000755e" + }, + { + "address": "0x140007553", + "size": 3, + "mnemonic": "mov", + "operands": "r8, qword ptr [rdx]" + }, + { + "address": "0x140007556", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r10" + }, + { + "address": "0x140007559", + "size": 5, + "mnemonic": "call", + "operands": "0x1400075e8" + }, + { + "address": "0x14000755e", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x140007562", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000aae0", + "name": "", + "blocks": [ + { + "address": "0x14000aae0", + "size": 16, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000aae0", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000aae4", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rcx" + }, + { + "address": "0x14000aae9", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], rdx" + }, + { + "address": "0x14000aaee", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x40], r8d" + }, + { + "address": "0x14000aaf3", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rdx]" + }, + { + "address": "0x14000aaf6", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rcx" + }, + { + "address": "0x14000aaf9", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a6d0" + }, + { + "address": "0x14000aafe", + "size": 2, + "mnemonic": "call", + "operands": "rax" + }, + { + "address": "0x14000ab00", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a700" + }, + { + "address": "0x14000ab05", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rax" + }, + { + "address": "0x14000ab08", + "size": 5, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14000ab0d", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rdx]" + }, + { + "address": "0x14000ab10", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 2" + }, + { + "address": "0x14000ab16", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a6d0" + }, + { + "address": "0x14000ab1b", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14000ab1f", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140006dd0", + "name": "", + "blocks": [ + { + "address": "0x140006dd0", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140006dd0", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140006dd2", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140006dd6", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140006dd9", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140006dde", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rax + 0x60], rbx" + }, + { + "address": "0x140006de2", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140006de6", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140006de7", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140006510", + "name": "", + "blocks": [ + { + "address": "0x140006510", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140006510", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x140006514", + "size": 4, + "mnemonic": "test", + "operands": "byte ptr [r8], 1" + }, + { + "address": "0x140006518", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx]" + }, + { + "address": "0x14000651b", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rcx" + }, + { + "address": "0x140006520", + "size": 2, + "mnemonic": "je", + "operands": "0x14000652f" + } + ], + "successors": [ + "0x14000652f", + "0x140006522" + ] + }, + { + "address": "0x14000652f", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000652f", + "size": 4, + "mnemonic": "or", + "operands": "r9d, 0xffffffff" + }, + { + "address": "0x140006533", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x30]" + }, + { + "address": "0x140006538", + "size": 5, + "mnemonic": "call", + "operands": "0x140009f50" + }, + { + "address": "0x14000653d", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x140006541", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140006522", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140006522", + "size": 4, + "mnemonic": "mov", + "operands": "eax, dword ptr [r8 + 0x14]" + }, + { + "address": "0x140006526", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rax + rcx]" + }, + { + "address": "0x14000652a", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rcx" + }, + { + "address": "0x14000652f", + "size": 4, + "mnemonic": "or", + "operands": "r9d, 0xffffffff" + }, + { + "address": "0x140006533", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x30]" + }, + { + "address": "0x140006538", + "size": 5, + "mnemonic": "call", + "operands": "0x140009f50" + }, + { + "address": "0x14000653d", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x140006541", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140007650", + "name": "", + "blocks": [ + ] + }, + { + "address": "0x140009f50", + "name": "", + "blocks": [ + { + "address": "0x140009f50", + "size": 30, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009f50", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rsp" + }, + { + "address": "0x140009f53", + "size": 1, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140009f54", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x140009f55", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140009f56", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x140009f58", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x140009f5a", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x140009f5c", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140009f5e", + "size": 7, + "mnemonic": "sub", + "operands": "rsp, 0x100" + }, + { + "address": "0x140009f65", + "size": 4, + "mnemonic": "movaps", + "operands": "xmmword ptr [rax - 0x48], xmm6" + }, + { + "address": "0x140009f69", + "size": 7, + "mnemonic": "mov", + "operands": "rax, qword ptr [rip + 0x270d0]" + }, + { + "address": "0x140009f70", + "size": 3, + "mnemonic": "xor", + "operands": "rax, rsp" + }, + { + "address": "0x140009f73", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0xe0], rax" + }, + { + "address": "0x140009f7b", + "size": 3, + "mnemonic": "mov", + "operands": "r13d, r9d" + }, + { + "address": "0x140009f7e", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r8" + }, + { + "address": "0x140009f81", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rdx" + }, + { + "address": "0x140009f84", + "size": 3, + "mnemonic": "mov", + "operands": "r12, rcx" + }, + { + "address": "0x140009f87", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x78], rcx" + }, + { + "address": "0x140009f8c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x60], rcx" + }, + { + "address": "0x140009f91", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x48], r9d" + }, + { + "address": "0x140009f96", + "size": 5, + "mnemonic": "call", + "operands": "0x140006da8" + }, + { + "address": "0x140009f9b", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x68], rax" + }, + { + "address": "0x140009fa0", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, rsi" + }, + { + "address": "0x140009fa3", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x140009fa6", + "size": 5, + "mnemonic": "call", + "operands": "0x1400075e0" + }, + { + "address": "0x140009fab", + "size": 2, + "mnemonic": "mov", + "operands": "edi, eax" + }, + { + "address": "0x140009fad", + "size": 4, + "mnemonic": "lea", + "operands": "r14, [rsi + 0x48]" + }, + { + "address": "0x140009fb1", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x70], r14" + }, + { + "address": "0x140009fb6", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [r14], 0" + }, + { + "address": "0x140009fba", + "size": 2, + "mnemonic": "je", + "operands": "0x140009fd3" + } + ], + "successors": [ + "0x140009fd3", + "0x140009fbc" + ] + }, + { + "address": "0x140009fd3", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009fd3", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140009fd8", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rax + 0x78], -2" + }, + { + "address": "0x140009fdc", + "size": 2, + "mnemonic": "je", + "operands": "0x140009ff2" + } + ], + "successors": [ + "0x140009ff2", + "0x140009fde" + ] + }, + { + "address": "0x140009fbc", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009fbc", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140009fc1", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rax + 0x78], -2" + }, + { + "address": "0x140009fc5", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000a256" + }, + { + "address": "0x140009fcb", + "size": 3, + "mnemonic": "mov", + "operands": "edi, dword ptr [r14]" + }, + { + "address": "0x140009fce", + "size": 3, + "mnemonic": "sub", + "operands": "edi, 2" + }, + { + "address": "0x140009fd1", + "size": 2, + "mnemonic": "jmp", + "operands": "0x140009ff2" + } + ], + "successors": [ + "0x140009ff2" + ] + }, + { + "address": "0x140009ff2", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009ff2", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140009ff7", + "size": 3, + "mnemonic": "inc", + "operands": "dword ptr [rax + 0x30]" + }, + { + "address": "0x140009ffa", + "size": 4, + "mnemonic": "add", + "operands": "rsi, 8" + }, + { + "address": "0x140009ffe", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x80], rsi" + }, + { + "address": "0x14000a006", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsi]" + }, + { + "address": "0x14000a009", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000a00b", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0xc8], rdx" + }, + { + "address": "0x14000a013", + "size": 3, + "mnemonic": "xorps", + "operands": "xmm0, xmm0" + }, + { + "address": "0x14000a016", + "size": 8, + "mnemonic": "movups", + "operands": "xmmword ptr [rsp + 0xd0], xmm0" + }, + { + "address": "0x14000a01e", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rbx + 8], edx" + }, + { + "address": "0x14000a021", + "size": 2, + "mnemonic": "je", + "operands": "0x14000a061" + } + ], + "successors": [ + "0x14000a061", + "0x14000a023" + ] + }, + { + "address": "0x140009fde", + "size": 15, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140009fde", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140009fe3", + "size": 3, + "mnemonic": "mov", + "operands": "edi, dword ptr [rax + 0x78]" + }, + { + "address": "0x140009fe6", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140009feb", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rax + 0x78], 0xfffffffe" + }, + { + "address": "0x140009ff2", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x140009ff7", + "size": 3, + "mnemonic": "inc", + "operands": "dword ptr [rax + 0x30]" + }, + { + "address": "0x140009ffa", + "size": 4, + "mnemonic": "add", + "operands": "rsi, 8" + }, + { + "address": "0x140009ffe", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x80], rsi" + }, + { + "address": "0x14000a006", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsi]" + }, + { + "address": "0x14000a009", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000a00b", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0xc8], rdx" + }, + { + "address": "0x14000a013", + "size": 3, + "mnemonic": "xorps", + "operands": "xmm0, xmm0" + }, + { + "address": "0x14000a016", + "size": 8, + "mnemonic": "movups", + "operands": "xmmword ptr [rsp + 0xd0], xmm0" + }, + { + "address": "0x14000a01e", + "size": 3, + "mnemonic": "cmp", + "operands": "dword ptr [rbx + 8], edx" + }, + { + "address": "0x14000a021", + "size": 2, + "mnemonic": "je", + "operands": "0x14000a061" + } + ], + "successors": [ + "0x14000a061", + "0x14000a023" + ] + }, + { + "address": "0x14000a061", + "size": 22, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a061", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0xc0], edx" + }, + { + "address": "0x14000a068", + "size": 8, + "mnemonic": "lea", + "operands": "rax, [rsp + 0xc0]" + }, + { + "address": "0x14000a070", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rax" + }, + { + "address": "0x14000a075", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], rdx" + }, + { + "address": "0x14000a07a", + "size": 8, + "mnemonic": "lea", + "operands": "rax, [rsp + 0xc0]" + }, + { + "address": "0x14000a082", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x50], rax" + }, + { + "address": "0x14000a087", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x58], rdx" + }, + { + "address": "0x14000a08c", + "size": 5, + "mnemonic": "lea", + "operands": "rax, [rsp + 0x50]" + }, + { + "address": "0x14000a091", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14000a096", + "size": 5, + "mnemonic": "lea", + "operands": "r9, [rsp + 0x30]" + }, + { + "address": "0x14000a09b", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, r13d" + }, + { + "address": "0x14000a09e", + "size": 2, + "mnemonic": "mov", + "operands": "edx, edi" + }, + { + "address": "0x14000a0a0", + "size": 8, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0xc0]" + }, + { + "address": "0x14000a0a8", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a520" + }, + { + "address": "0x14000a0ad", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14000a0ae", + "size": 8, + "mnemonic": "lea", + "operands": "rax, [rsp + 0xc0]" + }, + { + "address": "0x14000a0b6", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x88], rax" + }, + { + "address": "0x14000a0be", + "size": 8, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0xc8]" + }, + { + "address": "0x14000a0c6", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x90], rax" + }, + { + "address": "0x14000a0ce", + "size": 5, + "mnemonic": "mov", + "operands": "r15, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14000a0d3", + "size": 3, + "mnemonic": "cmp", + "operands": "r15, rax" + }, + { + "address": "0x14000a0d6", + "size": 6, + "mnemonic": "jb", + "operands": "0x14000a218" + } + ], + "successors": [ + "0x14000a218", + "0x14000a0dc" + ] + }, + { + "address": "0x14000a023", + "size": 13, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a023", + "size": 4, + "mnemonic": "movsxd", + "operands": "rdx, dword ptr [rbx + 8]" + }, + { + "address": "0x14000a027", + "size": 3, + "mnemonic": "add", + "operands": "rdx, rcx" + }, + { + "address": "0x14000a02a", + "size": 3, + "mnemonic": "movzx", + "operands": "ecx, byte ptr [rdx]" + }, + { + "address": "0x14000a02d", + "size": 3, + "mnemonic": "and", + "operands": "ecx, 0xf" + }, + { + "address": "0x14000a030", + "size": 7, + "mnemonic": "lea", + "operands": "r8, [rip - 0xa037]" + }, + { + "address": "0x14000a037", + "size": 9, + "mnemonic": "movsx", + "operands": "rax, byte ptr [rcx + r8 + 0x23d90]" + }, + { + "address": "0x14000a040", + "size": 3, + "mnemonic": "sub", + "operands": "rdx, rax" + }, + { + "address": "0x14000a043", + "size": 8, + "mnemonic": "mov", + "operands": "cl, byte ptr [rcx + r8 + 0x23da0]" + }, + { + "address": "0x14000a04b", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rdx - 4]" + }, + { + "address": "0x14000a04e", + "size": 2, + "mnemonic": "shr", + "operands": "eax, cl" + }, + { + "address": "0x14000a050", + "size": 7, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0xc0], eax" + }, + { + "address": "0x14000a057", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0xc8], rdx" + }, + { + "address": "0x14000a05f", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000a068" + } + ], + "successors": [ + "0x14000a068" + ] + }, + { + "address": "0x14000a218", + "size": 18, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000a218", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14000a21d", + "size": 4, + "mnemonic": "cmp", + "operands": "dword ptr [rax + 0x30], 0" + }, + { + "address": "0x14000a221", + "size": 2, + "mnemonic": "jle", + "operands": "0x14000a22b" + }, + { + "address": "0x14000a223", + "size": 5, + "mnemonic": "call", + "operands": "0x140007394" + }, + { + "address": "0x14000a228", + "size": 3, + "mnemonic": "dec", + "operands": "dword ptr [rax + 0x30]" + }, + { + "address": "0x14000a22b", + "size": 8, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0xe0]" + }, + { + "address": "0x14000a233", + "size": 3, + "mnemonic": "xor", + "operands": "rcx, rsp" + }, + { + "address": "0x14000a236", + "size": 5, + "mnemonic": "call", + "operands": "0x140005210" + }, + { + "address": "0x14000a23b", + "size": 8, + "mnemonic": "movaps", + "operands": "xmm6, xmmword ptr [rsp + 0xf0]" + }, + { + "address": "0x14000a243", + "size": 7, + "mnemonic": "add", + "operands": "rsp, 0x100" + }, + { + "address": "0x14000a24a", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000a24c", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000a24e", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14000a250", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14000a252", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000a253", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14000a254", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000a255", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000a0dc", + "size": 39, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a0dc", + "size": 5, + "mnemonic": "cmp", + "operands": "r15, qword ptr [rsp + 0x58]" + }, + { + "address": "0x14000a0e1", + "size": 6, + "mnemonic": "jbe", + "operands": "0x14000a218" + }, + { + "address": "0x14000a0e7", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x38]" + }, + { + "address": "0x14000a0ec", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000a0f1", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a464" + }, + { + "address": "0x14000a0f6", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], r15" + }, + { + "address": "0x14000a0fb", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14000a100", + "size": 4, + "mnemonic": "movups", + "operands": "xmm6, xmmword ptr [rbx + 0x10]" + }, + { + "address": "0x14000a104", + "size": 8, + "mnemonic": "movups", + "operands": "xmmword ptr [rsp + 0xb0], xmm6" + }, + { + "address": "0x14000a10c", + "size": 5, + "mnemonic": "movaps", + "operands": "xmm0, xmmword ptr [rsp + 0x30]" + }, + { + "address": "0x14000a111", + "size": 9, + "mnemonic": "movdqa", + "operands": "xmmword ptr [rsp + 0xa0], xmm0" + }, + { + "address": "0x14000a11a", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x38]" + }, + { + "address": "0x14000a11f", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x14000a122", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a464" + }, + { + "address": "0x14000a127", + "size": 3, + "mnemonic": "mov", + "operands": "eax, dword ptr [rbx + 0x10]" + }, + { + "address": "0x14000a12a", + "size": 3, + "mnemonic": "sub", + "operands": "r15, rax" + }, + { + "address": "0x14000a12d", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], r15" + }, + { + "address": "0x14000a132", + "size": 5, + "mnemonic": "lea", + "operands": "rax, [rsp + 0x30]" + }, + { + "address": "0x14000a137", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14000a13c", + "size": 3, + "mnemonic": "mov", + "operands": "r9d, edi" + }, + { + "address": "0x14000a13f", + "size": 8, + "mnemonic": "lea", + "operands": "r8, [rsp + 0xa0]" + }, + { + "address": "0x14000a147", + "size": 3, + "mnemonic": "mov", + "operands": "edx, r13d" + }, + { + "address": "0x14000a14a", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x50]" + }, + { + "address": "0x14000a14f", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a5f0" + }, + { + "address": "0x14000a154", + "size": 2, + "mnemonic": "mov", + "operands": "edi, eax" + }, + { + "address": "0x14000a156", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x44], eax" + }, + { + "address": "0x14000a15a", + "size": 8, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x40], 0" + }, + { + "address": "0x14000a162", + "size": 3, + "mnemonic": "xor", + "operands": "r9d, r9d" + }, + { + "address": "0x14000a165", + "size": 4, + "mnemonic": "movdqa", + "operands": "xmm0, xmm6" + }, + { + "address": "0x14000a169", + "size": 5, + "mnemonic": "psrldq", + "operands": "xmm0, 8" + }, + { + "address": "0x14000a16e", + "size": 4, + "mnemonic": "movd", + "operands": "eax, xmm0" + }, + { + "address": "0x14000a172", + "size": 4, + "mnemonic": "movdqa", + "operands": "xmm1, xmm6" + }, + { + "address": "0x14000a176", + "size": 5, + "mnemonic": "psrldq", + "operands": "xmm1, 4" + }, + { + "address": "0x14000a17b", + "size": 4, + "mnemonic": "movd", + "operands": "ecx, xmm1" + }, + { + "address": "0x14000a17f", + "size": 2, + "mnemonic": "test", + "operands": "ecx, ecx" + }, + { + "address": "0x14000a181", + "size": 4, + "mnemonic": "cmovne", + "operands": "r9d, eax" + }, + { + "address": "0x14000a185", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x40], r9d" + }, + { + "address": "0x14000a18a", + "size": 3, + "mnemonic": "test", + "operands": "r9d, r9d" + }, + { + "address": "0x14000a18d", + "size": 6, + "mnemonic": "je", + "operands": "0x14000a213" + } + ], + "successors": [ + "0x14000a213", + "0x14000a193" + ] + }, + { + "address": "0x14000a068", + "size": 21, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a068", + "size": 8, + "mnemonic": "lea", + "operands": "rax, [rsp + 0xc0]" + }, + { + "address": "0x14000a070", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x30], rax" + }, + { + "address": "0x14000a075", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x38], rdx" + }, + { + "address": "0x14000a07a", + "size": 8, + "mnemonic": "lea", + "operands": "rax, [rsp + 0xc0]" + }, + { + "address": "0x14000a082", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x50], rax" + }, + { + "address": "0x14000a087", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x58], rdx" + }, + { + "address": "0x14000a08c", + "size": 5, + "mnemonic": "lea", + "operands": "rax, [rsp + 0x50]" + }, + { + "address": "0x14000a091", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x14000a096", + "size": 5, + "mnemonic": "lea", + "operands": "r9, [rsp + 0x30]" + }, + { + "address": "0x14000a09b", + "size": 3, + "mnemonic": "mov", + "operands": "r8d, r13d" + }, + { + "address": "0x14000a09e", + "size": 2, + "mnemonic": "mov", + "operands": "edx, edi" + }, + { + "address": "0x14000a0a0", + "size": 8, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0xc0]" + }, + { + "address": "0x14000a0a8", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a520" + }, + { + "address": "0x14000a0ad", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14000a0ae", + "size": 8, + "mnemonic": "lea", + "operands": "rax, [rsp + 0xc0]" + }, + { + "address": "0x14000a0b6", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x88], rax" + }, + { + "address": "0x14000a0be", + "size": 8, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0xc8]" + }, + { + "address": "0x14000a0c6", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x90], rax" + }, + { + "address": "0x14000a0ce", + "size": 5, + "mnemonic": "mov", + "operands": "r15, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14000a0d3", + "size": 3, + "mnemonic": "cmp", + "operands": "r15, rax" + }, + { + "address": "0x14000a0d6", + "size": 6, + "mnemonic": "jb", + "operands": "0x14000a218" + } + ], + "successors": [ + "0x14000a218", + "0x14000a0dc" + ] + }, + { + "address": "0x14000a213", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a213", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000a0ae" + } + ], + "successors": [ + "0x14000a0ae" + ] + }, + { + "address": "0x14000a193", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a193", + "size": 3, + "mnemonic": "lea", + "operands": "eax, [rdi + 2]" + }, + { + "address": "0x14000a196", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [r14], eax" + }, + { + "address": "0x14000a199", + "size": 3, + "mnemonic": "lea", + "operands": "eax, [rcx - 1]" + }, + { + "address": "0x14000a19c", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 1" + }, + { + "address": "0x14000a19f", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14000a1b7" + }, + { + "address": "0x14000a1a1", + "size": 3, + "mnemonic": "movsxd", + "operands": "rcx, r9d" + }, + { + "address": "0x14000a1a4", + "size": 3, + "mnemonic": "add", + "operands": "rcx, qword ptr [rsi]" + }, + { + "address": "0x14000a1a7", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x103" + }, + { + "address": "0x14000a1ad", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, r12" + }, + { + "address": "0x14000a1b0", + "size": 5, + "mnemonic": "call", + "operands": "0x14000aae0" + }, + { + "address": "0x14000a1b5", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000a1ec" + } + ], + "successors": [ + "0x14000a1ec" + ] + }, + { + "address": "0x14000a0ae", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a0ae", + "size": 8, + "mnemonic": "lea", + "operands": "rax, [rsp + 0xc0]" + }, + { + "address": "0x14000a0b6", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x88], rax" + }, + { + "address": "0x14000a0be", + "size": 8, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0xc8]" + }, + { + "address": "0x14000a0c6", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x90], rax" + }, + { + "address": "0x14000a0ce", + "size": 5, + "mnemonic": "mov", + "operands": "r15, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14000a0d3", + "size": 3, + "mnemonic": "cmp", + "operands": "r15, rax" + }, + { + "address": "0x14000a0d6", + "size": 6, + "mnemonic": "jb", + "operands": "0x14000a218" + } + ], + "successors": [ + "0x14000a218", + "0x14000a0dc" + ] + }, + { + "address": "0x14000a1ec", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a1ec", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x68]" + }, + { + "address": "0x14000a1f1", + "size": 5, + "mnemonic": "call", + "operands": "0x140006dd0" + }, + { + "address": "0x14000a1f6", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000a213" + } + ], + "successors": [ + "0x14000a213" + ] + } + ] + }, + { + "address": "0x14000a7bc", + "name": "", + "blocks": [ + { + "address": "0x14000a7bc", + "size": 19, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a7bc", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000a7c1", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x14000a7c6", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x14000a7cb", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000a7cc", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x14000a7ce", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x14000a7d0", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000a7d2", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14000a7d4", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a7d8", + "size": 2, + "mnemonic": "mov", + "operands": "edi, ecx" + }, + { + "address": "0x14000a7da", + "size": 7, + "mnemonic": "lea", + "operands": "r15, [rip - 0xa7e1]" + }, + { + "address": "0x14000a7e1", + "size": 4, + "mnemonic": "or", + "operands": "r14, 0xffffffffffffffff" + }, + { + "address": "0x14000a7e5", + "size": 3, + "mnemonic": "mov", + "operands": "r12, r9" + }, + { + "address": "0x14000a7e8", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, r8" + }, + { + "address": "0x14000a7eb", + "size": 3, + "mnemonic": "mov", + "operands": "r13, rdx" + }, + { + "address": "0x14000a7ee", + "size": 8, + "mnemonic": "mov", + "operands": "rax, qword ptr [r15 + rdi*8 + 0x32db0]" + }, + { + "address": "0x14000a7f6", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14000a7f7", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, r14" + }, + { + "address": "0x14000a7fa", + "size": 6, + "mnemonic": "je", + "operands": "0x14000a8ae" + } + ], + "successors": [ + "0x14000a8ae", + "0x14000a800" + ] + }, + { + "address": "0x14000a8ae", + "size": 11, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000a8ae", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000a8b0", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14000a8b5", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x58]" + }, + { + "address": "0x14000a8ba", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14000a8bf", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a8c3", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000a8c5", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000a8c7", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14000a8c9", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14000a8cb", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000a8cc", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000a800", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a800", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000a803", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000a8b0" + }, + { + "address": "0x14000a809", + "size": 3, + "mnemonic": "cmp", + "operands": "r8, r9" + }, + { + "address": "0x14000a80c", + "size": 6, + "mnemonic": "je", + "operands": "0x14000a8a6" + } + ], + "successors": [ + "0x14000a8a6", + "0x14000a812" + ] + }, + { + "address": "0x14000a8a6", + "size": 12, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000a8a6", + "size": 8, + "mnemonic": "xchg", + "operands": "qword ptr [r15 + rdi*8 + 0x32db0], r14" + }, + { + "address": "0x14000a8ae", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000a8b0", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14000a8b5", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x58]" + }, + { + "address": "0x14000a8ba", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14000a8bf", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a8c3", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000a8c5", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000a8c7", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14000a8c9", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14000a8cb", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000a8cc", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000a812", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a812", + "size": 3, + "mnemonic": "mov", + "operands": "esi, dword ptr [rbp]" + }, + { + "address": "0x14000a815", + "size": 8, + "mnemonic": "mov", + "operands": "rbx, qword ptr [r15 + rsi*8 + 0x32d98]" + }, + { + "address": "0x14000a81d", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14000a81e", + "size": 3, + "mnemonic": "test", + "operands": "rbx, rbx" + }, + { + "address": "0x14000a821", + "size": 2, + "mnemonic": "je", + "operands": "0x14000a82e" + } + ], + "successors": [ + "0x14000a82e", + "0x14000a823" + ] + }, + { + "address": "0x14000a82e", + "size": 17, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a82e", + "size": 8, + "mnemonic": "mov", + "operands": "r15, qword ptr [r15 + rsi*8 + 0x24cf0]" + }, + { + "address": "0x14000a836", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000a838", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r15" + }, + { + "address": "0x14000a83b", + "size": 6, + "mnemonic": "mov", + "operands": "r8d, 0x800" + }, + { + "address": "0x14000a841", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x158f9]" + }, + { + "address": "0x14000a847", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x14000a84a", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000a84d", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000a8cd" + }, + { + "address": "0x14000a84f", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x158a3]" + }, + { + "address": "0x14000a855", + "size": 3, + "mnemonic": "cmp", + "operands": "eax, 0x57" + }, + { + "address": "0x14000a858", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000a887" + }, + { + "address": "0x14000a85a", + "size": 4, + "mnemonic": "lea", + "operands": "r8d, [rbx + 7]" + }, + { + "address": "0x14000a85e", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r15" + }, + { + "address": "0x14000a861", + "size": 7, + "mnemonic": "lea", + "operands": "rdx, [rip + 0x1a538]" + }, + { + "address": "0x14000a868", + "size": 5, + "mnemonic": "call", + "operands": "0x140011460" + }, + { + "address": "0x14000a86d", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14000a86f", + "size": 2, + "mnemonic": "je", + "operands": "0x14000a887" + } + ], + "successors": [ + "0x14000a887", + "0x14000a871" + ] + }, + { + "address": "0x14000a823", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a823", + "size": 3, + "mnemonic": "cmp", + "operands": "rbx, r14" + }, + { + "address": "0x14000a826", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000a8ed" + }, + { + "address": "0x14000a82c", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000a899" + } + ], + "successors": [ + "0x14000a899" + ] + }, + { + "address": "0x14000a887", + "size": 18, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000a887", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r14" + }, + { + "address": "0x14000a88a", + "size": 7, + "mnemonic": "lea", + "operands": "r15, [rip - 0xa891]" + }, + { + "address": "0x14000a891", + "size": 8, + "mnemonic": "xchg", + "operands": "qword ptr [r15 + rsi*8 + 0x32d98], rax" + }, + { + "address": "0x14000a899", + "size": 4, + "mnemonic": "add", + "operands": "rbp, 4" + }, + { + "address": "0x14000a89d", + "size": 3, + "mnemonic": "cmp", + "operands": "rbp, r12" + }, + { + "address": "0x14000a8a0", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000a812" + }, + { + "address": "0x14000a8a6", + "size": 8, + "mnemonic": "xchg", + "operands": "qword ptr [r15 + rdi*8 + 0x32db0], r14" + }, + { + "address": "0x14000a8ae", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000a8b0", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14000a8b5", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x58]" + }, + { + "address": "0x14000a8ba", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14000a8bf", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a8c3", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000a8c5", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000a8c7", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14000a8c9", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14000a8cb", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000a8cc", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000a871", + "size": 25, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000a871", + "size": 3, + "mnemonic": "xor", + "operands": "r8d, r8d" + }, + { + "address": "0x14000a874", + "size": 2, + "mnemonic": "xor", + "operands": "edx, edx" + }, + { + "address": "0x14000a876", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, r15" + }, + { + "address": "0x14000a879", + "size": 6, + "mnemonic": "call", + "operands": "qword ptr [rip + 0x158c1]" + }, + { + "address": "0x14000a87f", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rax" + }, + { + "address": "0x14000a882", + "size": 3, + "mnemonic": "test", + "operands": "rax, rax" + }, + { + "address": "0x14000a885", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000a8cd" + }, + { + "address": "0x14000a887", + "size": 3, + "mnemonic": "mov", + "operands": "rax, r14" + }, + { + "address": "0x14000a88a", + "size": 7, + "mnemonic": "lea", + "operands": "r15, [rip - 0xa891]" + }, + { + "address": "0x14000a891", + "size": 8, + "mnemonic": "xchg", + "operands": "qword ptr [r15 + rsi*8 + 0x32d98], rax" + }, + { + "address": "0x14000a899", + "size": 4, + "mnemonic": "add", + "operands": "rbp, 4" + }, + { + "address": "0x14000a89d", + "size": 3, + "mnemonic": "cmp", + "operands": "rbp, r12" + }, + { + "address": "0x14000a8a0", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000a812" + }, + { + "address": "0x14000a8a6", + "size": 8, + "mnemonic": "xchg", + "operands": "qword ptr [r15 + rdi*8 + 0x32db0], r14" + }, + { + "address": "0x14000a8ae", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000a8b0", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14000a8b5", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x58]" + }, + { + "address": "0x14000a8ba", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14000a8bf", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a8c3", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000a8c5", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000a8c7", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14000a8c9", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14000a8cb", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000a8cc", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000a899", + "size": 15, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000a899", + "size": 4, + "mnemonic": "add", + "operands": "rbp, 4" + }, + { + "address": "0x14000a89d", + "size": 3, + "mnemonic": "cmp", + "operands": "rbp, r12" + }, + { + "address": "0x14000a8a0", + "size": 6, + "mnemonic": "jne", + "operands": "0x14000a812" + }, + { + "address": "0x14000a8a6", + "size": 8, + "mnemonic": "xchg", + "operands": "qword ptr [r15 + rdi*8 + 0x32db0], r14" + }, + { + "address": "0x14000a8ae", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14000a8b0", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x50]" + }, + { + "address": "0x14000a8b5", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x58]" + }, + { + "address": "0x14000a8ba", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14000a8bf", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a8c3", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14000a8c5", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14000a8c7", + "size": 2, + "mnemonic": "pop", + "operands": "r13" + }, + { + "address": "0x14000a8c9", + "size": 2, + "mnemonic": "pop", + "operands": "r12" + }, + { + "address": "0x14000a8cb", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000a8cc", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140010630", + "name": "", + "blocks": [ + { + "address": "0x140010630", + "size": 19, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140010630", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140010635", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], r9" + }, + { + "address": "0x14001063a", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001063b", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001063f", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, r9" + }, + { + "address": "0x140010642", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, r8" + }, + { + "address": "0x140010645", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rdx]" + }, + { + "address": "0x140010647", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca20" + }, + { + "address": "0x14001064c", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14001064d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdi" + }, + { + "address": "0x140010650", + "size": 5, + "mnemonic": "call", + "operands": "0x14001081c" + }, + { + "address": "0x140010655", + "size": 2, + "mnemonic": "mov", + "operands": "edi, eax" + }, + { + "address": "0x140010657", + "size": 2, + "mnemonic": "mov", + "operands": "ecx, dword ptr [rbx]" + }, + { + "address": "0x140010659", + "size": 5, + "mnemonic": "call", + "operands": "0x14000ca74" + }, + { + "address": "0x14001065e", + "size": 2, + "mnemonic": "mov", + "operands": "eax, edi" + }, + { + "address": "0x140010660", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140010665", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140010669", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001066a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x1400018b0", + "name": "", + "blocks": [ + { + "address": "0x1400018b0", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x1400018b0", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1eb89]" + }, + { + "address": "0x1400018b7", + "size": 8, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 0x10], 0" + }, + { + "address": "0x1400018bf", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rcx + 8], rax" + }, + { + "address": "0x1400018c3", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1eb66]" + }, + { + "address": "0x1400018ca", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rcx], rax" + }, + { + "address": "0x1400018cd", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rcx" + }, + { + "address": "0x1400018d0", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000cda8", + "name": "", + "blocks": [ + { + "address": "0x14000cda8", + "size": 21, + "is_prolog": true, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000cda8", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rdx" + }, + { + "address": "0x14000cdad", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 8], ecx" + }, + { + "address": "0x14000cdb1", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000cdb2", + "size": 3, + "mnemonic": "mov", + "operands": "rbp, rsp" + }, + { + "address": "0x14000cdb5", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x40" + }, + { + "address": "0x14000cdb9", + "size": 5, + "mnemonic": "call", + "operands": "0x140012358" + }, + { + "address": "0x14000cdbe", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x10]" + }, + { + "address": "0x14000cdc2", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x18], rax" + }, + { + "address": "0x14000cdc6", + "size": 4, + "mnemonic": "lea", + "operands": "r9, [rbp + 0x28]" + }, + { + "address": "0x14000cdca", + "size": 4, + "mnemonic": "lea", + "operands": "rax, [rbp + 0x18]" + }, + { + "address": "0x14000cdce", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [rbp - 0x10], rax" + }, + { + "address": "0x14000cdd2", + "size": 4, + "mnemonic": "lea", + "operands": "r8, [rbp - 0x18]" + }, + { + "address": "0x14000cdd6", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 4" + }, + { + "address": "0x14000cddb", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbp - 0x20]" + }, + { + "address": "0x14000cddf", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbp + 0x20]" + }, + { + "address": "0x14000cde3", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp + 0x28], eax" + }, + { + "address": "0x14000cde6", + "size": 3, + "mnemonic": "mov", + "operands": "dword ptr [rbp - 0x20], eax" + }, + { + "address": "0x14000cde9", + "size": 5, + "mnemonic": "call", + "operands": "0x14000cac8" + }, + { + "address": "0x14000cdee", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x40" + }, + { + "address": "0x14000cdf2", + "size": 1, + "mnemonic": "pop", + "operands": "rbp" + }, + { + "address": "0x14000cdf3", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140002344", + "name": "", + "blocks": [ + { + "address": "0x140002344", + "size": 19, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140002344", + "size": 2, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140002346", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000234a", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14000234d", + "size": 5, + "mnemonic": "mov", + "operands": "byte ptr [rsp + 0x28], 1" + }, + { + "address": "0x140002352", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdx" + }, + { + "address": "0x140002355", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rip + 0x1e08c]" + }, + { + "address": "0x14000235c", + "size": 3, + "mnemonic": "xorps", + "operands": "xmm0, xmm0" + }, + { + "address": "0x14000235f", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x20], rax" + }, + { + "address": "0x140002364", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rbx], rcx" + }, + { + "address": "0x140002367", + "size": 4, + "mnemonic": "lea", + "operands": "rdx, [rbx + 8]" + }, + { + "address": "0x14000236b", + "size": 5, + "mnemonic": "lea", + "operands": "rcx, [rsp + 0x20]" + }, + { + "address": "0x140002370", + "size": 3, + "mnemonic": "movups", + "operands": "xmmword ptr [rdx], xmm0" + }, + { + "address": "0x140002373", + "size": 5, + "mnemonic": "call", + "operands": "0x1400060f0" + }, + { + "address": "0x140002378", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0x1e0f1]" + }, + { + "address": "0x14000237f", + "size": 3, + "mnemonic": "mov", + "operands": "qword ptr [rbx], rax" + }, + { + "address": "0x140002382", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rbx" + }, + { + "address": "0x140002385", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x140002389", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14000238a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140004538", + "name": "", + "blocks": [ + ] + }, + { + "address": "0x14001a95c", + "name": "", + "blocks": [ + { + "address": "0x14001a95c", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a95c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14001a961", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001a962", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001a966", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rdx" + }, + { + "address": "0x14001a969", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x14001a96c", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a9b4" + } + ], + "successors": [ + "0x14001a9b4", + "0x14001a96e" + ] + }, + { + "address": "0x14001a9b4", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001a9b4", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001a9b6", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001a9bb", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001a9bf", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001a9c0", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001a96e", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a96e", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001a971", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a9b4" + } + ], + "successors": [ + "0x14001a9b4", + "0x14001a973" + ] + }, + { + "address": "0x14001a973", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a973", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rcx]" + }, + { + "address": "0x14001a976", + "size": 3, + "mnemonic": "cmp", + "operands": "rbx, rdx" + }, + { + "address": "0x14001a979", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001a980" + }, + { + "address": "0x14001a97b", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdi" + }, + { + "address": "0x14001a97e", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001a9b6" + } + ], + "successors": [ + "0x14001a9b6" + ] + }, + { + "address": "0x14001a9b6", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001a9b6", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001a9bb", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001a9bf", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14001a9c0", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140011fe8", + "name": "", + "blocks": [ + { + "address": "0x140011fe8", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140011fe8", + "size": 7, + "mnemonic": "jmp", + "operands": "qword ptr [rip + 0xe1b1]" + } + ], + "successors": [ + "0x1400201a0" + ] + }, + { + "address": "0x1400201a0", + "size": 0, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140016930", + "name": "", + "blocks": [ + { + "address": "0x140016930", + "size": 10, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140016930", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140016935", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140016936", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001693a", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rdx" + }, + { + "address": "0x14001693d", + "size": 3, + "mnemonic": "mov", + "operands": "rdi, rcx" + }, + { + "address": "0x140016940", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140016943", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001694f" + }, + { + "address": "0x140016945", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rdx" + }, + { + "address": "0x140016948", + "size": 5, + "mnemonic": "call", + "operands": "0x140015200" + }, + { + "address": "0x14001694d", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14001696e" + } + ], + "successors": [ + "0x14001696e" + ] + }, + { + "address": "0x14001696e", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001696e", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140016973", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140016977", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140016978", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001d6d0", + "name": "", + "blocks": [ + { + "address": "0x14001d6d0", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001d6d0", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x28" + }, + { + "address": "0x14001d6d4", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001d6d7", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001d6f2" + }, + { + "address": "0x14001d6d9", + "size": 5, + "mnemonic": "call", + "operands": "0x14000d878" + }, + { + "address": "0x14001d6de", + "size": 6, + "mnemonic": "mov", + "operands": "dword ptr [rax], 0x16" + }, + { + "address": "0x14001d6e4", + "size": 5, + "mnemonic": "call", + "operands": "0x14000afb4" + }, + { + "address": "0x14001d6e9", + "size": 4, + "mnemonic": "or", + "operands": "rax, 0xffffffffffffffff" + }, + { + "address": "0x14001d6ed", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x28" + }, + { + "address": "0x14001d6f1", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001a81c", + "name": "", + "blocks": [ + { + "address": "0x14001a81c", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a81c", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001a81f", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a83b" + } + ], + "successors": [ + "0x14001a83b", + "0x14001a821" + ] + }, + { + "address": "0x14001a83b", + "size": 2, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001a83b", + "size": 5, + "mnemonic": "mov", + "operands": "eax, 0x7fffffff" + }, + { + "address": "0x14001a840", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001a821", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a821", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0xb3f8]" + }, + { + "address": "0x14001a828", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, rax" + }, + { + "address": "0x14001a82b", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a83b" + } + ], + "successors": [ + "0x14001a83b", + "0x14001a82d" + ] + }, + { + "address": "0x14001a82d", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001a82d", + "size": 3, + "mnemonic": "or", + "operands": "eax, 0xffffffff" + }, + { + "address": "0x14001a830", + "size": 8, + "mnemonic": "lock xadd", + "operands": "dword ptr [rcx + 0x15c], eax" + }, + { + "address": "0x14001a838", + "size": 2, + "mnemonic": "dec", + "operands": "eax" + }, + { + "address": "0x14001a83a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001a7e4", + "name": "", + "blocks": [ + { + "address": "0x14001a7e4", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a7e4", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001a7e7", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a81a" + } + ], + "successors": [ + "0x14001a81a", + "0x14001a7e9" + ] + }, + { + "address": "0x14001a81a", + "size": 1, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001a81a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001a7e9", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a7e9", + "size": 1, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x14001a7ea", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001a7ee", + "size": 7, + "mnemonic": "lea", + "operands": "rax, [rip + 0xb42b]" + }, + { + "address": "0x14001a7f5", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14001a7f8", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, rax" + }, + { + "address": "0x14001a7fb", + "size": 2, + "mnemonic": "je", + "operands": "0x14001a815" + } + ], + "successors": [ + "0x14001a815", + "0x14001a7fd" + ] + }, + { + "address": "0x14001a815", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001a815", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001a819", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001a81a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001a7fd", + "size": 10, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001a7fd", + "size": 6, + "mnemonic": "mov", + "operands": "eax, dword ptr [rcx + 0x15c]" + }, + { + "address": "0x14001a803", + "size": 1, + "mnemonic": "nop", + "operands": "" + }, + { + "address": "0x14001a804", + "size": 2, + "mnemonic": "test", + "operands": "eax, eax" + }, + { + "address": "0x14001a806", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001a815" + }, + { + "address": "0x14001a808", + "size": 5, + "mnemonic": "call", + "operands": "0x14001a21c" + }, + { + "address": "0x14001a80d", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, rbx" + }, + { + "address": "0x14001a810", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001a815", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001a819", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x14001a81a", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001952c", + "name": "", + "blocks": [ + { + "address": "0x14001952c", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001952c", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001952f", + "size": 6, + "mnemonic": "je", + "operands": "0x140019635" + } + ], + "successors": [ + "0x140019635", + "0x140019535" + ] + }, + { + "address": "0x140019635", + "size": 1, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140019635", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140019535", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019535", + "size": 1, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140019536", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001953a", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14001953d", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx + 0x18]" + }, + { + "address": "0x140019541", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17cd0]" + }, + { + "address": "0x140019548", + "size": 2, + "mnemonic": "je", + "operands": "0x14001954f" + } + ], + "successors": [ + "0x14001954f", + "0x14001954a" + ] + }, + { + "address": "0x14001954f", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001954f", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x20]" + }, + { + "address": "0x140019553", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17cc6]" + }, + { + "address": "0x14001955a", + "size": 2, + "mnemonic": "je", + "operands": "0x140019561" + } + ], + "successors": [ + "0x140019561", + "0x14001955c" + ] + }, + { + "address": "0x14001954a", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001954a", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001954f", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x20]" + }, + { + "address": "0x140019553", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17cc6]" + }, + { + "address": "0x14001955a", + "size": 2, + "mnemonic": "je", + "operands": "0x140019561" + } + ], + "successors": [ + "0x140019561", + "0x14001955c" + ] + }, + { + "address": "0x140019561", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019561", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x28]" + }, + { + "address": "0x140019565", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17cbc]" + }, + { + "address": "0x14001956c", + "size": 2, + "mnemonic": "je", + "operands": "0x140019573" + } + ], + "successors": [ + "0x140019573", + "0x14001956e" + ] + }, + { + "address": "0x14001955c", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001955c", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140019561", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x28]" + }, + { + "address": "0x140019565", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17cbc]" + }, + { + "address": "0x14001956c", + "size": 2, + "mnemonic": "je", + "operands": "0x140019573" + } + ], + "successors": [ + "0x140019573", + "0x14001956e" + ] + }, + { + "address": "0x140019573", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019573", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x30]" + }, + { + "address": "0x140019577", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17cb2]" + }, + { + "address": "0x14001957e", + "size": 2, + "mnemonic": "je", + "operands": "0x140019585" + } + ], + "successors": [ + "0x140019585", + "0x140019580" + ] + }, + { + "address": "0x14001956e", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001956e", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140019573", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x30]" + }, + { + "address": "0x140019577", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17cb2]" + }, + { + "address": "0x14001957e", + "size": 2, + "mnemonic": "je", + "operands": "0x140019585" + } + ], + "successors": [ + "0x140019585", + "0x140019580" + ] + }, + { + "address": "0x140019585", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019585", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x38]" + }, + { + "address": "0x140019589", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17ca8]" + }, + { + "address": "0x140019590", + "size": 2, + "mnemonic": "je", + "operands": "0x140019597" + } + ], + "successors": [ + "0x140019597", + "0x140019592" + ] + }, + { + "address": "0x140019580", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019580", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140019585", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x38]" + }, + { + "address": "0x140019589", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17ca8]" + }, + { + "address": "0x140019590", + "size": 2, + "mnemonic": "je", + "operands": "0x140019597" + } + ], + "successors": [ + "0x140019597", + "0x140019592" + ] + }, + { + "address": "0x140019597", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019597", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x40]" + }, + { + "address": "0x14001959b", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17c9e]" + }, + { + "address": "0x1400195a2", + "size": 2, + "mnemonic": "je", + "operands": "0x1400195a9" + } + ], + "successors": [ + "0x1400195a9", + "0x1400195a4" + ] + }, + { + "address": "0x140019592", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019592", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140019597", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x40]" + }, + { + "address": "0x14001959b", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17c9e]" + }, + { + "address": "0x1400195a2", + "size": 2, + "mnemonic": "je", + "operands": "0x1400195a9" + } + ], + "successors": [ + "0x1400195a9", + "0x1400195a4" + ] + }, + { + "address": "0x1400195a9", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400195a9", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x48]" + }, + { + "address": "0x1400195ad", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17c94]" + }, + { + "address": "0x1400195b4", + "size": 2, + "mnemonic": "je", + "operands": "0x1400195bb" + } + ], + "successors": [ + "0x1400195bb", + "0x1400195b6" + ] + }, + { + "address": "0x1400195a4", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400195a4", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x1400195a9", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x48]" + }, + { + "address": "0x1400195ad", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17c94]" + }, + { + "address": "0x1400195b4", + "size": 2, + "mnemonic": "je", + "operands": "0x1400195bb" + } + ], + "successors": [ + "0x1400195bb", + "0x1400195b6" + ] + }, + { + "address": "0x1400195bb", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400195bb", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x68]" + }, + { + "address": "0x1400195bf", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17ca2]" + }, + { + "address": "0x1400195c6", + "size": 2, + "mnemonic": "je", + "operands": "0x1400195cd" + } + ], + "successors": [ + "0x1400195cd", + "0x1400195c8" + ] + }, + { + "address": "0x1400195b6", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400195b6", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x1400195bb", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x68]" + }, + { + "address": "0x1400195bf", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17ca2]" + }, + { + "address": "0x1400195c6", + "size": 2, + "mnemonic": "je", + "operands": "0x1400195cd" + } + ], + "successors": [ + "0x1400195cd", + "0x1400195c8" + ] + }, + { + "address": "0x1400195cd", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400195cd", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x70]" + }, + { + "address": "0x1400195d1", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17c98]" + }, + { + "address": "0x1400195d8", + "size": 2, + "mnemonic": "je", + "operands": "0x1400195df" + } + ], + "successors": [ + "0x1400195df", + "0x1400195da" + ] + }, + { + "address": "0x1400195c8", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400195c8", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x1400195cd", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x70]" + }, + { + "address": "0x1400195d1", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17c98]" + }, + { + "address": "0x1400195d8", + "size": 2, + "mnemonic": "je", + "operands": "0x1400195df" + } + ], + "successors": [ + "0x1400195df", + "0x1400195da" + ] + }, + { + "address": "0x1400195df", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400195df", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x78]" + }, + { + "address": "0x1400195e3", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17c8e]" + }, + { + "address": "0x1400195ea", + "size": 2, + "mnemonic": "je", + "operands": "0x1400195f1" + } + ], + "successors": [ + "0x1400195f1", + "0x1400195ec" + ] + }, + { + "address": "0x1400195da", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400195da", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x1400195df", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x78]" + }, + { + "address": "0x1400195e3", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17c8e]" + }, + { + "address": "0x1400195ea", + "size": 2, + "mnemonic": "je", + "operands": "0x1400195f1" + } + ], + "successors": [ + "0x1400195f1", + "0x1400195ec" + ] + }, + { + "address": "0x1400195f1", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400195f1", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x80]" + }, + { + "address": "0x1400195f8", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17c81]" + }, + { + "address": "0x1400195ff", + "size": 2, + "mnemonic": "je", + "operands": "0x140019606" + } + ], + "successors": [ + "0x140019606", + "0x140019601" + ] + }, + { + "address": "0x1400195ec", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x1400195ec", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x1400195f1", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x80]" + }, + { + "address": "0x1400195f8", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17c81]" + }, + { + "address": "0x1400195ff", + "size": 2, + "mnemonic": "je", + "operands": "0x140019606" + } + ], + "successors": [ + "0x140019606", + "0x140019601" + ] + }, + { + "address": "0x140019606", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019606", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x88]" + }, + { + "address": "0x14001960d", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17c74]" + }, + { + "address": "0x140019614", + "size": 2, + "mnemonic": "je", + "operands": "0x14001961b" + } + ], + "successors": [ + "0x14001961b", + "0x140019616" + ] + }, + { + "address": "0x140019601", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019601", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140019606", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x88]" + }, + { + "address": "0x14001960d", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17c74]" + }, + { + "address": "0x140019614", + "size": 2, + "mnemonic": "je", + "operands": "0x14001961b" + } + ], + "successors": [ + "0x14001961b", + "0x140019616" + ] + }, + { + "address": "0x14001961b", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001961b", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x90]" + }, + { + "address": "0x140019622", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17c67]" + }, + { + "address": "0x140019629", + "size": 2, + "mnemonic": "je", + "operands": "0x140019630" + } + ], + "successors": [ + "0x140019630", + "0x14001962b" + ] + }, + { + "address": "0x140019616", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019616", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001961b", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x90]" + }, + { + "address": "0x140019622", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17c67]" + }, + { + "address": "0x140019629", + "size": 2, + "mnemonic": "je", + "operands": "0x140019630" + } + ], + "successors": [ + "0x140019630", + "0x14001962b" + ] + }, + { + "address": "0x140019630", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140019630", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140019634", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140019635", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001962b", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001962b", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140019630", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140019634", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140019635", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140019b54", + "name": "", + "blocks": [ + { + "address": "0x140019b54", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019b54", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x140019b57", + "size": 2, + "mnemonic": "je", + "operands": "0x140019bbf" + } + ], + "successors": [ + "0x140019bbf", + "0x140019b59" + ] + }, + { + "address": "0x140019bbf", + "size": 1, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140019bbf", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140019b59", + "size": 6, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019b59", + "size": 1, + "mnemonic": "push", + "operands": "rbx" + }, + { + "address": "0x140019b5a", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140019b5e", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140019b61", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rcx]" + }, + { + "address": "0x140019b64", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17695]" + }, + { + "address": "0x140019b6b", + "size": 2, + "mnemonic": "je", + "operands": "0x140019b72" + } + ], + "successors": [ + "0x140019b72", + "0x140019b6d" + ] + }, + { + "address": "0x140019b72", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019b72", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 8]" + }, + { + "address": "0x140019b76", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x1768b]" + }, + { + "address": "0x140019b7d", + "size": 2, + "mnemonic": "je", + "operands": "0x140019b84" + } + ], + "successors": [ + "0x140019b84", + "0x140019b7f" + ] + }, + { + "address": "0x140019b6d", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019b6d", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140019b72", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 8]" + }, + { + "address": "0x140019b76", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x1768b]" + }, + { + "address": "0x140019b7d", + "size": 2, + "mnemonic": "je", + "operands": "0x140019b84" + } + ], + "successors": [ + "0x140019b84", + "0x140019b7f" + ] + }, + { + "address": "0x140019b84", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019b84", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x10]" + }, + { + "address": "0x140019b88", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17681]" + }, + { + "address": "0x140019b8f", + "size": 2, + "mnemonic": "je", + "operands": "0x140019b96" + } + ], + "successors": [ + "0x140019b96", + "0x140019b91" + ] + }, + { + "address": "0x140019b7f", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019b7f", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140019b84", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x10]" + }, + { + "address": "0x140019b88", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x17681]" + }, + { + "address": "0x140019b8f", + "size": 2, + "mnemonic": "je", + "operands": "0x140019b96" + } + ], + "successors": [ + "0x140019b96", + "0x140019b91" + ] + }, + { + "address": "0x140019b96", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019b96", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x58]" + }, + { + "address": "0x140019b9a", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x176b7]" + }, + { + "address": "0x140019ba1", + "size": 2, + "mnemonic": "je", + "operands": "0x140019ba8" + } + ], + "successors": [ + "0x140019ba8", + "0x140019ba3" + ] + }, + { + "address": "0x140019b91", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019b91", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140019b96", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x58]" + }, + { + "address": "0x140019b9a", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x176b7]" + }, + { + "address": "0x140019ba1", + "size": 2, + "mnemonic": "je", + "operands": "0x140019ba8" + } + ], + "successors": [ + "0x140019ba8", + "0x140019ba3" + ] + }, + { + "address": "0x140019ba8", + "size": 3, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019ba8", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x60]" + }, + { + "address": "0x140019bac", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x176ad]" + }, + { + "address": "0x140019bb3", + "size": 2, + "mnemonic": "je", + "operands": "0x140019bba" + } + ], + "successors": [ + "0x140019bba", + "0x140019bb5" + ] + }, + { + "address": "0x140019ba3", + "size": 4, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019ba3", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140019ba8", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x60]" + }, + { + "address": "0x140019bac", + "size": 7, + "mnemonic": "cmp", + "operands": "rcx, qword ptr [rip + 0x176ad]" + }, + { + "address": "0x140019bb3", + "size": 2, + "mnemonic": "je", + "operands": "0x140019bba" + } + ], + "successors": [ + "0x140019bba", + "0x140019bb5" + ] + }, + { + "address": "0x140019bba", + "size": 3, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140019bba", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140019bbe", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140019bbf", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140019bb5", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140019bb5", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140019bba", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140019bbe", + "size": 1, + "mnemonic": "pop", + "operands": "rbx" + }, + { + "address": "0x140019bbf", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001d410", + "name": "", + "blocks": [ + { + "address": "0x14001d410", + "size": 7, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001d410", + "size": 3, + "mnemonic": "mov", + "operands": "r9, r8" + }, + { + "address": "0x14001d413", + "size": 3, + "mnemonic": "mov", + "operands": "r11, rdx" + }, + { + "address": "0x14001d416", + "size": 3, + "mnemonic": "mov", + "operands": "r10, rcx" + }, + { + "address": "0x14001d419", + "size": 3, + "mnemonic": "test", + "operands": "r8, r8" + }, + { + "address": "0x14001d41c", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001d430" + }, + { + "address": "0x14001d41e", + "size": 2, + "mnemonic": "xor", + "operands": "eax, eax" + }, + { + "address": "0x14001d420", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000a6d0", + "name": "", + "blocks": [ + { + "address": "0x14000a6d0", + "size": 5, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a6d0", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rcx" + }, + { + "address": "0x14000a6d5", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rdx" + }, + { + "address": "0x14000a6da", + "size": 5, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x10], r8d" + }, + { + "address": "0x14000a6df", + "size": 7, + "mnemonic": "mov", + "operands": "r9, 0x19930520" + }, + { + "address": "0x14000a6e6", + "size": 5, + "mnemonic": "jmp", + "operands": "0x14000a6f0" + } + ], + "successors": [ + "0x14000a6f0" + ] + }, + { + "address": "0x14000a6f0", + "size": 1, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000a6f0", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000a700", + "name": "", + "blocks": [ + { + "address": "0x14000a700", + "size": 1, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000a700", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14000a520", + "name": "", + "blocks": [ + { + "address": "0x14000a520", + "size": 35, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a520", + "size": 3, + "mnemonic": "mov", + "operands": "r11, rsp" + }, + { + "address": "0x14000a523", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r11 + 0x18], rbx" + }, + { + "address": "0x14000a527", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r11 + 0x20], r9" + }, + { + "address": "0x14000a52b", + "size": 4, + "mnemonic": "mov", + "operands": "dword ptr [rsp + 0x10], edx" + }, + { + "address": "0x14000a52f", + "size": 1, + "mnemonic": "push", + "operands": "rbp" + }, + { + "address": "0x14000a530", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x14000a531", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000a532", + "size": 2, + "mnemonic": "push", + "operands": "r12" + }, + { + "address": "0x14000a534", + "size": 2, + "mnemonic": "push", + "operands": "r13" + }, + { + "address": "0x14000a536", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14000a538", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x14000a53a", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14000a53e", + "size": 4, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx + 8]" + }, + { + "address": "0x14000a542", + "size": 3, + "mnemonic": "xor", + "operands": "bpl, bpl" + }, + { + "address": "0x14000a545", + "size": 3, + "mnemonic": "xor", + "operands": "r14b, r14b" + }, + { + "address": "0x14000a548", + "size": 4, + "mnemonic": "mov", + "operands": "qword ptr [r11 + 8], rax" + }, + { + "address": "0x14000a54c", + "size": 2, + "mnemonic": "xor", + "operands": "edi, edi" + }, + { + "address": "0x14000a54e", + "size": 3, + "mnemonic": "mov", + "operands": "r12, r9" + }, + { + "address": "0x14000a551", + "size": 3, + "mnemonic": "mov", + "operands": "r13d, r8d" + }, + { + "address": "0x14000a554", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14000a557", + "size": 4, + "mnemonic": "lea", + "operands": "rsi, [rax - 1]" + }, + { + "address": "0x14000a55b", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rsi" + }, + { + "address": "0x14000a55e", + "size": 2, + "mnemonic": "cmp", + "operands": "dword ptr [rcx], edi" + }, + { + "address": "0x14000a560", + "size": 2, + "mnemonic": "jle", + "operands": "0x14000a5a5" + }, + { + "address": "0x14000a562", + "size": 4, + "mnemonic": "mov", + "operands": "r12d, dword ptr [r11 + 0x10]" + }, + { + "address": "0x14000a566", + "size": 3, + "mnemonic": "cmp", + "operands": "edi, r12d" + }, + { + "address": "0x14000a569", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000a571" + }, + { + "address": "0x14000a56b", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rax" + }, + { + "address": "0x14000a56e", + "size": 3, + "mnemonic": "mov", + "operands": "bpl, 1" + }, + { + "address": "0x14000a571", + "size": 3, + "mnemonic": "cmp", + "operands": "edi, r13d" + }, + { + "address": "0x14000a574", + "size": 2, + "mnemonic": "jne", + "operands": "0x14000a57c" + }, + { + "address": "0x14000a576", + "size": 3, + "mnemonic": "mov", + "operands": "r15, rax" + }, + { + "address": "0x14000a579", + "size": 3, + "mnemonic": "mov", + "operands": "r14b, 1" + }, + { + "address": "0x14000a57c", + "size": 3, + "mnemonic": "test", + "operands": "bpl, bpl" + }, + { + "address": "0x14000a57f", + "size": 2, + "mnemonic": "je", + "operands": "0x14000a586" + } + ], + "successors": [ + "0x14000a586", + "0x14000a581" + ] + } + ] + }, + { + "address": "0x14000a5f0", + "name": "", + "blocks": [ + { + "address": "0x14000a5f0", + "size": 11, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a5f0", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14000a5f5", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rsi" + }, + { + "address": "0x14000a5fa", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14000a5fb", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000a5ff", + "size": 5, + "mnemonic": "mov", + "operands": "rdi, qword ptr [rsp + 0x60]" + }, + { + "address": "0x14000a604", + "size": 2, + "mnemonic": "mov", + "operands": "ebx, edx" + }, + { + "address": "0x14000a606", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, r8" + }, + { + "address": "0x14000a609", + "size": 3, + "mnemonic": "mov", + "operands": "r10, rcx" + }, + { + "address": "0x14000a60c", + "size": 4, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rdi + 8]" + }, + { + "address": "0x14000a610", + "size": 4, + "mnemonic": "cmp", + "operands": "rdx, qword ptr [r8 + 8]" + }, + { + "address": "0x14000a614", + "size": 2, + "mnemonic": "ja", + "operands": "0x14000a68d" + } + ], + "successors": [ + "0x14000a68d", + "0x14000a616" + ] + }, + { + "address": "0x14000a68d", + "size": 6, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000a68d", + "size": 3, + "mnemonic": "or", + "operands": "eax, 0xffffffff" + }, + { + "address": "0x14000a690", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14000a695", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14000a69a", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000a69e", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000a69f", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14000a616", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a616", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [rcx + 8], rdx" + }, + { + "address": "0x14000a61a", + "size": 2, + "mnemonic": "ja", + "operands": "0x14000a68d" + } + ], + "successors": [ + "0x14000a68d", + "0x14000a61c" + ] + }, + { + "address": "0x14000a61c", + "size": 17, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a61c", + "size": 4, + "mnemonic": "mov", + "operands": "rcx, qword ptr [r8 + 8]" + }, + { + "address": "0x14000a620", + "size": 3, + "mnemonic": "mov", + "operands": "rax, rdx" + }, + { + "address": "0x14000a623", + "size": 4, + "mnemonic": "sub", + "operands": "rax, qword ptr [r10 + 8]" + }, + { + "address": "0x14000a627", + "size": 3, + "mnemonic": "sub", + "operands": "rcx, rdx" + }, + { + "address": "0x14000a62a", + "size": 3, + "mnemonic": "cmp", + "operands": "rax, rcx" + }, + { + "address": "0x14000a62d", + "size": 2, + "mnemonic": "jge", + "operands": "0x14000a65c" + }, + { + "address": "0x14000a62f", + "size": 4, + "mnemonic": "movups", + "operands": "xmm0, xmmword ptr [r10]" + }, + { + "address": "0x14000a633", + "size": 5, + "mnemonic": "movups", + "operands": "xmmword ptr [rsp + 0x20], xmm0" + }, + { + "address": "0x14000a638", + "size": 4, + "mnemonic": "cmp", + "operands": "rdx, qword ptr [r10 + 8]" + }, + { + "address": "0x14000a63c", + "size": 2, + "mnemonic": "jbe", + "operands": "0x14000a689" + }, + { + "address": "0x14000a63e", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x20]" + }, + { + "address": "0x14000a643", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x28]" + }, + { + "address": "0x14000a648", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a464" + }, + { + "address": "0x14000a64d", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x28]" + }, + { + "address": "0x14000a652", + "size": 2, + "mnemonic": "inc", + "operands": "ebx" + }, + { + "address": "0x14000a654", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [rdi + 8], rax" + }, + { + "address": "0x14000a658", + "size": 2, + "mnemonic": "ja", + "operands": "0x14000a63e" + } + ], + "successors": [ + "0x14000a63e", + "0x14000a65a" + ] + }, + { + "address": "0x14000a63e", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a63e", + "size": 5, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rsp + 0x20]" + }, + { + "address": "0x14000a643", + "size": 5, + "mnemonic": "lea", + "operands": "rdx, [rsp + 0x28]" + }, + { + "address": "0x14000a648", + "size": 5, + "mnemonic": "call", + "operands": "0x14000a464" + }, + { + "address": "0x14000a64d", + "size": 5, + "mnemonic": "mov", + "operands": "rax, qword ptr [rsp + 0x28]" + }, + { + "address": "0x14000a652", + "size": 2, + "mnemonic": "inc", + "operands": "ebx" + }, + { + "address": "0x14000a654", + "size": 4, + "mnemonic": "cmp", + "operands": "qword ptr [rdi + 8], rax" + }, + { + "address": "0x14000a658", + "size": 2, + "mnemonic": "ja", + "operands": "0x14000a63e" + } + ], + "successors": [ + "0x14000a63e", + "0x14000a65a" + ] + }, + { + "address": "0x14000a65a", + "size": 1, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a65a", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000a689" + } + ], + "successors": [ + "0x14000a689" + ] + }, + { + "address": "0x14000a689", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14000a689", + "size": 2, + "mnemonic": "mov", + "operands": "eax, ebx" + }, + { + "address": "0x14000a68b", + "size": 2, + "mnemonic": "jmp", + "operands": "0x14000a690" + } + ], + "successors": [ + "0x14000a690" + ] + }, + { + "address": "0x14000a690", + "size": 5, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14000a690", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14000a695", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x48]" + }, + { + "address": "0x14000a69a", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x30" + }, + { + "address": "0x14000a69e", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x14000a69f", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001081c", + "name": "", + "blocks": [ + { + "address": "0x14001081c", + "size": 14, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001081c", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140010821", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x140010826", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x18], rsi" + }, + { + "address": "0x14001082b", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x14001082c", + "size": 2, + "mnemonic": "push", + "operands": "r14" + }, + { + "address": "0x14001082e", + "size": 2, + "mnemonic": "push", + "operands": "r15" + }, + { + "address": "0x140010830", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140010834", + "size": 3, + "mnemonic": "mov", + "operands": "rax, qword ptr [rcx]" + }, + { + "address": "0x140010837", + "size": 3, + "mnemonic": "mov", + "operands": "rsi, rcx" + }, + { + "address": "0x14001083a", + "size": 3, + "mnemonic": "mov", + "operands": "rdx, qword ptr [rax]" + }, + { + "address": "0x14001083d", + "size": 3, + "mnemonic": "test", + "operands": "rdx, rdx" + }, + { + "address": "0x140010840", + "size": 2, + "mnemonic": "jne", + "operands": "0x14001084a" + }, + { + "address": "0x140010842", + "size": 3, + "mnemonic": "or", + "operands": "eax, 0xffffffff" + }, + { + "address": "0x140010845", + "size": 5, + "mnemonic": "jmp", + "operands": "0x140010918" + } + ], + "successors": [ + "0x140010918" + ] + }, + { + "address": "0x140010918", + "size": 8, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140010918", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x40]" + }, + { + "address": "0x14001091d", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x48]" + }, + { + "address": "0x140010922", + "size": 5, + "mnemonic": "mov", + "operands": "rsi, qword ptr [rsp + 0x50]" + }, + { + "address": "0x140010927", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001092b", + "size": 2, + "mnemonic": "pop", + "operands": "r15" + }, + { + "address": "0x14001092d", + "size": 2, + "mnemonic": "pop", + "operands": "r14" + }, + { + "address": "0x14001092f", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140010930", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x14001a21c", + "name": "", + "blocks": [ + { + "address": "0x14001a21c", + "size": 2, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x14001a21c", + "size": 3, + "mnemonic": "test", + "operands": "rcx, rcx" + }, + { + "address": "0x14001a21f", + "size": 6, + "mnemonic": "je", + "operands": "0x14001a323" + } + ], + "successors": [ + "0x14001a323", + "0x14001a225" + ] + }, + { + "address": "0x14001a323", + "size": 1, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001a323", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x14001a225", + "size": 55, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x14001a225", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x14001a22a", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 0x10], rbp" + }, + { + "address": "0x14001a22f", + "size": 1, + "mnemonic": "push", + "operands": "rsi" + }, + { + "address": "0x14001a230", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001a234", + "size": 5, + "mnemonic": "mov", + "operands": "ebp, 7" + }, + { + "address": "0x14001a239", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x14001a23c", + "size": 2, + "mnemonic": "mov", + "operands": "edx, ebp" + }, + { + "address": "0x14001a23e", + "size": 5, + "mnemonic": "call", + "operands": "0x140019ea8" + }, + { + "address": "0x14001a243", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbx + 0x38]" + }, + { + "address": "0x14001a247", + "size": 2, + "mnemonic": "mov", + "operands": "edx, ebp" + }, + { + "address": "0x14001a249", + "size": 5, + "mnemonic": "call", + "operands": "0x140019ea8" + }, + { + "address": "0x14001a24e", + "size": 3, + "mnemonic": "lea", + "operands": "esi, [rbp + 5]" + }, + { + "address": "0x14001a251", + "size": 2, + "mnemonic": "mov", + "operands": "edx, esi" + }, + { + "address": "0x14001a253", + "size": 4, + "mnemonic": "lea", + "operands": "rcx, [rbx + 0x70]" + }, + { + "address": "0x14001a257", + "size": 5, + "mnemonic": "call", + "operands": "0x140019ea8" + }, + { + "address": "0x14001a25c", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rbx + 0xd0]" + }, + { + "address": "0x14001a263", + "size": 2, + "mnemonic": "mov", + "operands": "edx, esi" + }, + { + "address": "0x14001a265", + "size": 5, + "mnemonic": "call", + "operands": "0x140019ea8" + }, + { + "address": "0x14001a26a", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rbx + 0x130]" + }, + { + "address": "0x14001a271", + "size": 3, + "mnemonic": "lea", + "operands": "edx, [rbp - 5]" + }, + { + "address": "0x14001a274", + "size": 5, + "mnemonic": "call", + "operands": "0x140019ea8" + }, + { + "address": "0x14001a279", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x140]" + }, + { + "address": "0x14001a280", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001a285", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x148]" + }, + { + "address": "0x14001a28c", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001a291", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x150]" + }, + { + "address": "0x14001a298", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001a29d", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rbx + 0x160]" + }, + { + "address": "0x14001a2a4", + "size": 2, + "mnemonic": "mov", + "operands": "edx, ebp" + }, + { + "address": "0x14001a2a6", + "size": 5, + "mnemonic": "call", + "operands": "0x140019ea8" + }, + { + "address": "0x14001a2ab", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rbx + 0x198]" + }, + { + "address": "0x14001a2b2", + "size": 2, + "mnemonic": "mov", + "operands": "edx, ebp" + }, + { + "address": "0x14001a2b4", + "size": 5, + "mnemonic": "call", + "operands": "0x140019ea8" + }, + { + "address": "0x14001a2b9", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rbx + 0x1d0]" + }, + { + "address": "0x14001a2c0", + "size": 2, + "mnemonic": "mov", + "operands": "edx, esi" + }, + { + "address": "0x14001a2c2", + "size": 5, + "mnemonic": "call", + "operands": "0x140019ea8" + }, + { + "address": "0x14001a2c7", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rbx + 0x230]" + }, + { + "address": "0x14001a2ce", + "size": 2, + "mnemonic": "mov", + "operands": "edx, esi" + }, + { + "address": "0x14001a2d0", + "size": 5, + "mnemonic": "call", + "operands": "0x140019ea8" + }, + { + "address": "0x14001a2d5", + "size": 7, + "mnemonic": "lea", + "operands": "rcx, [rbx + 0x290]" + }, + { + "address": "0x14001a2dc", + "size": 3, + "mnemonic": "lea", + "operands": "edx, [rbp - 5]" + }, + { + "address": "0x14001a2df", + "size": 5, + "mnemonic": "call", + "operands": "0x140019ea8" + }, + { + "address": "0x14001a2e4", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x2a0]" + }, + { + "address": "0x14001a2eb", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001a2f0", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x2a8]" + }, + { + "address": "0x14001a2f7", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001a2fc", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x2b0]" + }, + { + "address": "0x14001a303", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001a308", + "size": 7, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx + 0x2b8]" + }, + { + "address": "0x14001a30f", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x14001a314", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x14001a319", + "size": 5, + "mnemonic": "mov", + "operands": "rbp, qword ptr [rsp + 0x38]" + }, + { + "address": "0x14001a31e", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x14001a322", + "size": 1, + "mnemonic": "pop", + "operands": "rsi" + }, + { + "address": "0x14001a323", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + }, + { + "address": "0x140019ea8", + "name": "", + "blocks": [ + { + "address": "0x140019ea8", + "size": 7, + "is_prolog": false, + "is_epilog": false, + "instructions": [ + { + "address": "0x140019ea8", + "size": 5, + "mnemonic": "mov", + "operands": "qword ptr [rsp + 8], rbx" + }, + { + "address": "0x140019ead", + "size": 1, + "mnemonic": "push", + "operands": "rdi" + }, + { + "address": "0x140019eae", + "size": 4, + "mnemonic": "sub", + "operands": "rsp, 0x20" + }, + { + "address": "0x140019eb2", + "size": 4, + "mnemonic": "lea", + "operands": "rdi, [rcx + rdx*8]" + }, + { + "address": "0x140019eb6", + "size": 3, + "mnemonic": "mov", + "operands": "rbx, rcx" + }, + { + "address": "0x140019eb9", + "size": 3, + "mnemonic": "cmp", + "operands": "rcx, rdi" + }, + { + "address": "0x140019ebc", + "size": 2, + "mnemonic": "je", + "operands": "0x140019ecf" + } + ], + "successors": [ + "0x140019ecf", + "0x140019ebe" + ] + }, + { + "address": "0x140019ecf", + "size": 4, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140019ecf", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140019ed4", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140019ed8", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140019ed9", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + }, + { + "address": "0x140019ebe", + "size": 9, + "is_prolog": false, + "is_epilog": true, + "instructions": [ + { + "address": "0x140019ebe", + "size": 3, + "mnemonic": "mov", + "operands": "rcx, qword ptr [rbx]" + }, + { + "address": "0x140019ec1", + "size": 5, + "mnemonic": "call", + "operands": "0x140011b00" + }, + { + "address": "0x140019ec6", + "size": 4, + "mnemonic": "add", + "operands": "rbx, 8" + }, + { + "address": "0x140019eca", + "size": 3, + "mnemonic": "cmp", + "operands": "rbx, rdi" + }, + { + "address": "0x140019ecd", + "size": 2, + "mnemonic": "jne", + "operands": "0x140019ebe" + }, + { + "address": "0x140019ecf", + "size": 5, + "mnemonic": "mov", + "operands": "rbx, qword ptr [rsp + 0x30]" + }, + { + "address": "0x140019ed4", + "size": 4, + "mnemonic": "add", + "operands": "rsp, 0x20" + }, + { + "address": "0x140019ed8", + "size": 1, + "mnemonic": "pop", + "operands": "rdi" + }, + { + "address": "0x140019ed9", + "size": 1, + "mnemonic": "ret", + "operands": "" + } + ], + "successors": [ + ] + } + ] + } + ] +} diff --git a/types.hpp b/types.hpp new file mode 100644 index 0000000..00efecd --- /dev/null +++ b/types.hpp @@ -0,0 +1,169 @@ +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include + + +using namespace std; +using addr_t = uint64_t; + +struct ImportEntry +{ + addr_t address; + string name; + string library; +}; + +struct IndirectTarget +{ + addr_t instruction_addr; + addr_t resolved_target; + string name; + string library; + bool resolved; +}; + +struct Instruction +{ + addr_t address; + vector bytes; + string mnemonic; + string operands; + uint8_t size; +}; + +struct BasicBlock +{ + addr_t address; + vector instructions; + vector successors; + bool is_prolog; + bool is_epilog; +}; + +struct Function +{ + addr_t address; + string name; + vector blocks; +}; + +struct CFG +{ + string binary_path; + string arch_str; + string format_str; + addr_t entry_point; + vector functions; + vector imports; + vector indirect_targets; + + static string escapeJSON(const string& s) + { + ostringstream os; + for (char c : s) + { + switch (c) + { + case '"': os << "\\\""; break; + case '\\': os << "\\\\"; break; + case '\n': os << "\\n"; break; + case '\r': os << "\\r"; break; + case '\t': os << "\\t"; break; + default: os << c; + } + } + return os.str(); + } + + string toJSON() const + { + ostringstream os; + os << "{\n"; + os << " \"binary\": \"" << escapeJSON(binary_path) << "\",\n"; + os << " \"arch\": \"" << escapeJSON(arch_str) << "\",\n"; + os << " \"format\": \"" << escapeJSON(format_str) << "\",\n"; + os << " \"entry_point\": \"0x" << hex << entry_point << "\",\n"; + os << " \"imports\": [\n"; + for (size_t i = 0; i < imports.size(); ++i) { + os << " {\n"; + os << " \"address\": \"0x" << hex << imports[i].address << "\",\n"; + os << " \"name\": \"" << escapeJSON(imports[i].name) << "\",\n"; + os << " \"library\": \"" << escapeJSON(imports[i].library) << "\"\n"; + os << " }"; + if (i < imports.size() - 1) os << ","; + os << "\n"; + } + os << " ],\n"; + + os << " \"indirect_targets\": [\n"; + for (size_t i = 0; i < indirect_targets.size(); ++i) { + const auto& it = indirect_targets[i]; + os << " {\n"; + os << " \"instruction\": \"0x" << hex << it.instruction_addr << "\",\n"; + if (it.resolved) { + os << " \"resolved_target\": \"0x" << it.resolved_target << "\",\n"; + } else { + os << " \"resolved_target\": null,\n"; + } + os << " \"name\": \"" << escapeJSON(it.name) << "\",\n"; + os << " \"library\": \"" << escapeJSON(it.library) << "\"\n"; + os << " }"; + if (i < indirect_targets.size() - 1) os << ","; + os << "\n"; + } + os << " ],\n"; + + os << " \"functions\": [\n"; + for (size_t i = 0; i < functions.size(); ++i) { + const auto& f = functions[i]; + os << " {\n"; + os << " \"address\": \"0x" << hex << f.address << "\",\n"; + os << " \"name\": \"" << escapeJSON(f.name) << "\",\n"; + os << " \"blocks\": [\n"; + for (size_t j = 0; j < f.blocks.size(); ++j) { + const auto& b = f.blocks[j]; + os << " {\n"; + os << " \"address\": \"0x" << hex << b.address << "\",\n"; + os << " \"size\": " << dec << b.instructions.size() << ",\n"; + os << " \"is_prolog\": " << (b.is_prolog ? "true" : "false") << ",\n"; + os << " \"is_epilog\": " << (b.is_epilog ? "true" : "false") << ",\n"; + os << " \"instructions\": [\n"; + for (size_t k = 0; k < b.instructions.size(); ++k) { + const auto& inst = b.instructions[k]; + os << " {\n"; + os << " \"address\": \"0x" << hex << inst.address << "\",\n"; + os << " \"size\": " << dec << (int)inst.size << ",\n"; + os << " \"mnemonic\": \"" << escapeJSON(inst.mnemonic) << "\",\n"; + os << " \"operands\": \"" << escapeJSON(inst.operands) << "\"\n"; + os << " }"; + if (k < b.instructions.size() - 1) os << ","; + os << "\n"; + } + os << " ],\n"; + os << " \"successors\": [\n"; + for (size_t k = 0; k < b.successors.size(); ++k) { + os << " \"0x" << hex << b.successors[k] << "\""; + if (k < b.successors.size() - 1) os << ","; + os << "\n"; + } + os << " ]\n"; + os << " }"; + if (j < f.blocks.size() - 1) os << ","; + os << "\n"; + } + os << " ]\n"; + os << " }"; + if (i < functions.size() - 1) os << ","; + os << "\n"; + } + os << " ]\n"; + os << "}\n"; + return os.str(); + } +};