Paper deep dive
SoK: AI-Augmented Binary Reversing
Yujeong Kwon, Yiyue Zhang, Shakhzod Yuldoshkhujaev, Kexin Pei, Dokyung Song, Hyungjoon Koo
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 96%
Last extracted: 6/20/2026, 9:43:09 AM
Summary
This SoK (Systematization of Knowledge) paper provides a comprehensive taxonomy and analysis of the AI-augmented binary reversing field. It analyzes 144 research papers published since 2015 to bridge the gap between conventional binary reversing (static, dynamic, triage, and security testing) and AI-driven approaches (ML, LLMs, and Agentic AI). The authors introduce a two-pipeline model where conventional analysis produces 'binary-derived artifacts' that serve as the interface for AI-augmented pipelines, which use representation learning and advanced reasoning to perform tasks like classification, recovery, and summarization across 22 distinct domains.
Entities (7)
Relation Signals (4)
LLM → augments → Binary Reversing
confidence 100% · Recent advances in machine learning, large language models (LLMs), and agentic AI systems have accelerated the adoption of AI-augmented binary reversing.
Static Analysis → produces → Binary-derived Artifacts
confidence 100% · Static analysis... produces analysis artifacts that facilitate downstream code-semantic recovery.
Binary-derived Artifacts → servesasinterfacefor → AI-augmented Binary Reversing Pipeline
confidence 100% · These artifacts constitute the interface between the two pipelines.
Agentic AI → performs → Inference Task
confidence 90% · recent approaches (e.g., LLM- and agent-based AI systems) additially leverage reasoning, planning, prompting, and tool-use capabilities to coordinate analysis steps
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Binary reversing is fundamental to software understanding, vulnerability discovery, malware investigation, and firmware auditing. However, it remains inherently challenging due to the irreversible loss of semantic information during compilation. Recent advances in machine learning, large language models (LLMs), and agentic AI systems have accelerated the adoption of AI-augmented binary reversing. Yet, the resulting body of work has become increasingly fragmented across reversing domains, artifact representations, learning approaches, and evaluation practices. This paper presents the first comprehensive systematization of knowledge on AI-augmented binary reversing. We analyze 144 research papers published since 2015, and organize them into 22 binary reversing domains according to the inference tasks. We further introduce a unified taxonomy spanning conventional and AI-augmented reversing pipelines. Our taxonomy connects traditional analysis techniques, binary-derived artifacts, representation strategies, learning paradigms, and downstream inference tasks, while clarifying the emerging roles of LLMs and agentic AI systems. By establishing a common vocabulary and structured framework, we provide a holistic view of the field's evolution over the past decade. Our study reveals common structures underlying seemingly disparate approaches, highlights persistent technical challenges and evaluation gaps, and identifies promising opportunities for future research. Collectively, these insights clarify the current state of the field and provide a foundation for the next generation of reliable and scalable AI-augmented binary reversing systems.
Tags
Links
- Source: https://arxiv.org/abs/2606.17398v1
- Canonical: https://arxiv.org/abs/2606.17398v1
Trouble viewing inline? Open PDF directly →
Full Text
128,719 characters extracted from source content.
Expand or collapse full text
SoK: AI-Augmented Binary Reversing Yujeong Kwon † Yiyue Zhang † Shakhzod Yuldoshkhujaev † Kexin Pei ‡ Dokyung Song § Hyungjoon Koo † † Sungkyunkwan University ‡ The University of Chicago § Yonsei University Abstract—Binary reversing is fundamental to software under- standing, vulnerability discovery, malware investigation, and firmware auditing. However, it remains inherently challenging due to the irreversible loss of semantic information during com- pilation. Recent advances in machine learning, large language models (LLMs), and agentic AI systems have accelerated the adoption of AI-augmented binary reversing. Yet, the resulting body of work has become increasingly fragmented across re- versing domains, artifact representations, learning approaches, and evaluation practices. This paper presents the first compre- hensive systematization of knowledge on AI-augmented binary reversing. We analyze 144 research papers published since 2015, and organize them into 22 binary reversing domains according to the inference tasks. We further introduce a unified taxonomy spanning conventional and AI-augmented reversing pipelines. Our taxonomy connects traditional analysis techniques, binary-derived artifacts, representation strategies, learning paradigms, and downstream inference tasks, while clarifying the emerging roles of LLMs and agentic AI systems. By establishing a common vocabulary and structured frame- work, we provide a holistic view of the field’s evolution over the past decade. Our study reveals common structures underlying seemingly disparate approaches, highlights persistent techni- cal challenges and evaluation gaps, and identifies promising opportunities for future research. Collectively, these insights clarify the current state of the field and provide a foundation for the next generation of reliable and scalable AI-augmented binary reversing systems. 1. Introduction As modern society increasingly relies on distributed software whose source code is unavailable or inaccessible, understanding the inner workings of executable binaries has become a critical capability. Binary reverse engineering (hereinafter referred to as binary reversing) is the process of inferring higher-level code semantics and design intent (e.g., program behaviors, algorithms, protocols, and vulnera- bilities) from low-level program structures (e.g., machine in- structions, control flows, and data flows). This process plays a crucial role in securing computing systems by enabling vulnerability discovery [1]–[5], malware investigation [6], [7], attack comprehension [8]–[10], software supply-chain risk assessment [11], [12], and patch validation [13]–[15]. Corresponding author: Hyungjoon Koo (kevin.koo@skku.edu) Beyond practical security applications, binary reversing is indispensable for software maintenance [16], interoper- ability [17], [18], digital forensics [19]–[22], intellectual- property verification [23]–[26], and legacy system migra- tion [27]–[29]. Despite its importance, binary reversing remains fun- damentally challenging. Compilation irreversibly discards high-level semantic information, while compiler optimiza- tions further transform program structure, causing semanti- cally equivalent source code to yield substantially different binaries across architectures, compilers, and optimization settings. Moreover, many binary reversing tasks require reasoning about program behavior and are subject to well- known computability limits, rendering perfect automated semantic recovery infeasible in general. The challenge is further amplified by the scale and complexity of modern software, as well as adversarial techniques such as obfusca- tion, packing, encryption, and anti-analysis mechanisms. As a result, binary reversing is not a single task but a family of interdependent program semantic inference problems that require combining evidence across multiple analysis modal- ities and abstraction levels. For decades, researchers have addressed these chal- lenges through triage [30]–[33], static analysis [34]–[36], dynamic analysis [37]–[40], symbolic reasoning [41]–[44], and program testing [45]–[49], supported by a wide range of automated techniques and tools [50]–[56]. Unfortunately, these approaches only partially alleviate the core difficul- ties of binary reversing. Specifically, static and symbolic analyses must approximate behaviors that are undecidable or infeasible to recover precisely, dynamic analyses and testing observe only explored executions, and all of these techniques operate on binaries from which names, types, abstractions, and design intent may have been irreversibly lost. As a result, practical reversing still relies heavily on human experts to reconcile incomplete, ambiguous, and heterogeneous evidence. This persistent gap between what automated analyses can reliably recover and what analysts need to understand has made machine learning (ML) and large language models (LLMs) increasingly attractive as complementary mecha- nisms for augmenting binary reversing workflows. In partic- ular, the remarkable success of deep learning has fueled the adoption of ML across every stage of the binary-reversing pipeline, from low-level code recovery to high-level seman- tic understanding. These approaches aim to learn patterns from binary-derived artifacts, automate analysis tasks, and arXiv:2606.17398v1 [cs.CR] 16 Jun 2026 assist analysts in recovering program semantics. However, the rapid adoption of ML, LLMs and re- lated AI techniques has produced a large and increasingly fragmented body of research on AI-driven binary reversing across a broad spectrum of domains. Although individual studies have demonstrated promising results on specific tasks, this proliferation has outpaced our collective under- standing of the field, leaving its methodological founda- tions, evaluation practices, strengths, limitations, and open challenges largely unsystematized. This lack of synthesis has concrete consequences. Studies often reach apparently conflicting conclusions (§6.2.3) because they adopt different task formulations, datasets, baselines, and evaluation pro- tocols; similar modeling ideas are repeatedly repurposed across adjacent applications without a clear account of what is genuinely transferable; and reported progress frequently remains concentrated on benchmark-level improvements rather than integration into real-world reversing workflows. As a result, it remains difficult for researchers and practi- tioners to assess which AI techniques are robust, where they provide meaningful analyst assistance, and which barriers must be overcome for practical deployment. To provide such a consolidated view, this SoK organizes the fragmented literature around three research questions: (RQ1) What is the current maturity and landscape of AI- augmented binary reversing? (RQ2) What validity risks arise from datasets, tools, representations, and learning mod- els in the AI-augmented reversing pipeline? (RQ3) What open challenges and research directions are most critical to achieving advanced AI-augmented reversing? Our key observation is that AI-augmented binary re- versing complements, rather than replaces, conventional re- versing, and the two approaches mutually reinforce one an- other. Simply put, conventional analysis techniques produce binary-derived artifacts through a variety of reversing tech- niques, subsequently serving as the learning data consumed by AI systems. Viewed through this lens, we introduce a two-pipeline model connected by an artifact interface; namely, executable binaries are translated into analysis arti- facts, artifacts into AI-consumable representations, and rep- resentations into inferred semantic properties. This artifact- centric and inference-oriented perspective reveals a com- mon workflow underlying seemingly disparate approaches and provides a principled basis for reasoning about their capabilities, limitations, and opportunities afforded by ML, LLMs, and agentic AI systems. Taking this perspective, we collect and investigate 144 research papers published since 2015, across 11 top-tier venues. We then organize these works into 22 binary re- versing domains by inference task they support and place them within a unified taxonomy spanning conventional and AI-augmented binary reversing pipelines. By systematically examining the relationships among reversing tasks, analysis artifacts, representation strategies, learning paradigms, and evaluation methodologies, our study provides a holistic view of the field’s evolution. The resulting systematization yields 10 insights, highlighting well-studied and underexplored domains, persistent technical challenges, and promising re- search directions. Furthermore, we provide an interactive visualization platform 1 (Figure 3 in Appendix) to support researchers and practitioners in developing reliable, scalable, and generalizable AI-augmented binary reversing systems. The main contributions of our paper are as follows: • We present the first comprehensive systematization of AI- augmented binary reversing spanning 22 domains. • We introduce a unified taxonomy that bridges conven- tional and AI-augmented binary reversing through anal- ysis artifacts, and develop an accompanying website for interactive visualization. • We evaluate the maturity of the field, identify persistent challenges, and highlight promising directions for future AI-augmented binary reversing research. 2. Methodology and Scope Literature Collection. We first collected candidate papers using domain-specific keywords in Google Scholar [57] and screened publications from 11 top-tier venues in security (S&P, CCS, USENIX Security, NDSS), software engineer- ing (ICSE, FSE), and artificial intelligence (AAAI, IJCAI, NeurIPS, ICLR, ICML) published since 2015. We chose 2015 as the starting point because it marked the publication of Shin et al.’s [58] function boundary detection work, one of the pioneering deep-learning-based approaches for identifying function boundaries in stripped binaries. For each domain, we constructed search queries by combining domain-specific synonyms with binary-related terms. For example, function-name recovery queries included alterna- tive formulations (e.g., function name prediction, function symbol name recovery, binary, executable, and stripped bi- naries) to improve recall despite terminological variation. We then included studies whose primary contribution is the application of ML, LLMs, or other AI techniques to binary reversing tasks. Starting from these papers, we further expanded the corpus through backward and forward snow- balling, incorporating highly cited studies (more than 10 citations at the time of writing) discovered outside the initial venue set. This process enhances coverage and reduces selection bias and the risk of overlooking influential research published in other venues. Our final corpus comprises 144 papers spanning 22 binary reversing domains (§3.2). Scope. We deliberately exclude approaches that rely on source code during inference, restricting our study to binary reversing tasks. In particular, we focus on research that leverages binary analysis artifacts as inputs to machine learning models. Finally, we limit our scope to native ex- ecutables produced by compilers. Consequently, Android bytecode (e.g., Java/Dalvik applications) and interpreted- language bytecode (e.g., Python) fall outside the scope of this study. Meanwhile, existing surveys of AI-augmented bi- nary analysis focus on individual domains, including binary code similarity [59], information (i.e., function signatures, variable types, and names) recovery [60], malware detection 1. https://sok-aire.vercel.app Conventional Binary Reversing Pipeline (§4) Code representations Binary facts Snapshots Logical expressions Test sets Graph representations Text streams Numerical statistics Learning Paradigm (§5.4) Rule-based reasoning Discriminative learning Generative learning LLM-based fine-tuning Reinforcement learning AI-Augmented Binary Reversing Pipeline (§5) Embedding (§5.3) Context-dependent Context-independent Canonicalization ($5.2.1) ScaleReplace RemoveMap TransformExtract Encoding (§5.3) Dense Sparse Artifact Form ($5.1) Numeric descriptors Graphs Images Sequences Artifact-centered Data Representation Model Training System / Model Reasoning system Discriminative model Generative model LLM-fine-tuned model Domain-oriented Reasoning / Learning for Inference Inference for Semantic Understanding Binary Reversing Domains by Inference Type (§ 3.2) Application Foundation D12D13D14D20D15D17 D22 D21 ClassificationDetectionClusteringDiscoveryReconstructionRecovery RestorationSummarization D02D05D06 D03D04 D07D08D09D10D11 D01 Known vulnerability D19 D16 Authorship Toolchain provenance Malware family Code protection Known Algorithm Malware presence Patch presence Unknown vulnerability PseudocodeCode summary Code boundary Code similarity Symbolic path Data/Taint Flow Indirect call target Struct layout Variable type Function signature Function symbol name Variable symbol name D18 Security Testing Static Analysis Triage Dynamic Analysis Tokenization (§5.2.2) (Sequence only) Agent-/LLM-based Inference Analysis Artifacts Prompt Reason Plan Memory Feedback for Further analysis EXE Feature Engineering Debloatingtarget Tool AtomicSyntactic Rule-basedData-driven Analysis Modes (Techniques → Goals) Figure 1: A taxonomy overview for binary reversing spanning conventional (§4) and AI-augmented (§5) pipelines. Drawing on 144 research papers published between 2015 and 2025, we organize the field into 22 binary reversing domains by inference type (§3.2) and situate these domains within two principled pipelines. The conventional pipeline is structured around four analysis modes (Table 2): triage, static analysis, dynamic analysis, and security testing, each of which is associated with distinct analysis goals and techniques. These analyses produce eight classes of analysis artifacts, such as code and graph representations (Table 3), which serve as the interface (§5.1) to the AI-augmented pipeline. Earlier approaches transform them through data representation (§5.2–§5.3) and model-learning processes (§5.4) to enable downstream inferences, whereas recent approaches exploit the reasoning, planning, prompting, and tool-use capabilities of LLMs and agentic AI systems. The resulting inferences can either guide subsequent analyses or assist in understanding underlying code semantics. and classification [61], [62], and vulnerability detection [63], [64]. Although valuable within their respective areas, they do not provide a unified cross-domain perspective. As a result, the field still lacks a comprehensive systematization of AI-augmented binary reversing. 3. A Taxonomy for Binary Reversing 3.1. Taxonomy Overview Two Pipelines and Artifact Interface. The conventional binary reversing pipeline differs fundamentally from its AI- based counterpart: the former relies primarily on binary analysis techniques, explicit reasoning, and human expertise, whereas the latter introduces learning-based mechanisms that automate part of this inference process by leverag- ing patterns learned from massive datasets. Although both pipelines share the common objective of recovering high- level code semantics, the AI-centric paradigm enables more scalable analysis and rapid triage while reducing the depen- dence on domain expertise and manual effort. At its core, the transition is driven by binary-derived artifacts that tradi- tional analyses and reversing tools produce. These artifacts provide structured observations that can be transformed into model-consumable representations and embedded in high- dimensional feature spaces. Such transformation naturally recasts a wide range of binary analysis tasks as inference problems amenable to learning-based approaches, includ- ing detection, classification, clustering, recovery, retrieval, and summarization. In essence, the conventional pipeline describes how analysis artifacts are generated, whereas the AI-augmented pipeline leverages the artifacts for representa- tion learning and downstream semantic inference. Crucially, binary-derived artifacts constitute the interface between the two pipelines. Taxonomy Overview. Figure 1 presents our taxonomy of binary reversing. We structure the conventional binary reversing pipeline around four recurring analysis modes: triage, static analysis, dynamic analysis, and security testing. Each mode has distinct analysis objectives and supporting techniques and each produces analysis artifacts that facilitate downstream code-semantic recovery. These artifacts form the interface between the conventional and AI-augmented pipelines. To consume these artifacts as learning data, the AI-augmented binary reversing pipeline applies a non-trivial representation process (i.e., feature engineering): artifact selection, canonicalization, tokenization, encoding, and em- bedding. Subsequent model-learning choices determine how Table 1: A taxonomy of AI-augmented binary reversing domains. We define 22 reversing domains with 8 inference types in §3.2. The rightmost column reports the number of surveyed papers assigned to each domain. DID CategoryBinary Reversing Domain by Inference Type# D01 Foundation Code protection restoration0 D02 Foundation Code boundary (instruction/function) detection6 D03 Foundation Data (taint) flow reconstruction6 D04 Foundation Indirect call target reconstruction1 D05 Foundation Code similarity detection23 D06 Foundation Symbolic path discovery1 D07 Foundation Data structure/struct layout recovery3 D08 Foundation Variable type recovery6 D09 Foundation Function signature recovery2 D10 Foundation Function symbol name recovery8 D11 Foundation Variable symbol name recovery6 D12 Application Programmer authorship classification2 D13 Application Toolchain provenance classification3 D14 Application Malware family classification15 D15 Application Debloating target detection2 D16 Application Known vulnerability detection/clustering8 D17 Application Malware detection16 D18 Application Patch presence detection (binary diffing)2 D19 Application Unknown vulnerability discovery/clustering9 D20 Application Known algorithm classification2 D21 Application Code summarization5 D22 Application Pseudocode recovery (decompilation)6 -Others XAI (2), Code representation learning (6) Dataset drift (3), Obfuscated code generation (1) 12 Total 144 the feature representations support eight major inference tasks: classification, detection, clustering, discovery, recon- struction, recovery, restoration, and summarization. Earlier AI-augmented approaches primarily learn from engineered representations of binary-derived artifacts, whereas recent approaches (e.g., LLM- and agent-based AI systems) addi- tionally leverage reasoning, planning, prompting, and tool- use capabilities to coordinate analysis steps across hetero- geneous sources of evidence. In both cases, the analysis insights either guide subsequent reversing activities or assist analysts in understanding underlying code semantics. 3.2. Reversing Domains by Inference Type Inference Types. We identify eight inference types in bi- nary reversing domains: 1classification, which assigns a target to one of predefined categories; 2 clustering, which groups similar instances into emergent unlabeled clusters; 3 detection, which determines whether a property is present; 4 discovery, which identifies previously unknown candi- dates of interest for subsequent validation;5reconstruction, which infers latent structural relations; 6 recovery, which recovers source-level semantics lost during compilation; 7 restoration, which reverses intentional concealment by code or data transformations; and 8 summarization, which generates concise semantic descriptions. Papers outside our taxonomy are grouped under Others. Domains. Foundation domains focus on recovering, recon- structing, or restoring binary-derived artifacts and program properties, whereas application domains leverage such ar- tifacts to infer higher-level semantics, security, provenance, or explanatory insights. This distinction highlights a com- mon progression from artifact-centric inference to analyst- oriented reasoning across AI-augmented binary reversing. When a paper spans multiple domains, we assign it to the domain that best reflects its primary inference task. Table 1 organizes AI-augmented binary reversing according to in- ference type and scheme, which yield 22 binary-reversing domains and 132 papers. A small number of additional studies fall outside of our predefined reversing domains, addressing explainable AI (XAI) techniques [65], [66], rep- resentation learning [67]–[71], dataset drift [72]–[74], or code obfuscation [75]. As a final note, we deliberately retain domains with only a few studies to make underexplored areas visible. 4. Conventional Binary Reversing Analysis Modes. We taxonomize conventional binary re- versing into four recurring analysis modes: 1triage orients the investigation;2static analysis reconstructs program structure without execution;3 dynamic analysis primarily monitors concrete executions and runtime behavior (i.e., ob- servational); and4security testing actively perturbs inputs, program states, execution environments, or path constraints to validate hypotheses (i.e., interventional). These modes interact iteratively rather than forming a strict waterfall: a static observation may motivate a dynamic trace; a trace may reveal an unpacked payload for static reanalysis; and a failed test may send the analyst back to revise control- flow, data-flow, or type hypotheses. Table 2 details these modes by mapping each to its analysis goals, representative techniques, and resulting analysis artifacts. Triage. Triage often serves as the entry point of the con- ventional binary reversing pipeline. It aims to character- ize a binary, establish its analysis context, and prioritize subsequent investigation efforts. Accordingly, triage relies on lightweight techniques that inspect structural, functional, provenance, and protection-related signals rather than at- tempting full semantic recovery. The information obtained at this stage provides coarse but actionable artifacts for dis- closing the nature of the binary (i.e., profiling), identifying its external capabilities and dependencies (e.g., libraries, network communications), inferring how it may have been produced or protected, and determining which hypotheses warrant further investigation in other analysis modes. Static Analysis. Static analysis aims to reconstruct program structure and approximate semantics without executing the binary. It operates over decoded code, lifted representations, and abstract program relations to recover control flow, data flow, memory layout, type information, dependencies, and source-like abstractions. The artifacts offer broad, whole- program coverage, including execution paths that may never be observed at runtime. As a result, static-analysis artifacts constitute the primary structural and semantic foundation Table 2: Four recurring analysis modes in conventional binary analysis: triage, static analysis, dynamic analysis, and security testing (§4). Each analysis mode leverages a set of analysis techniques to achieve particular objectives, producing corresponding analysis artifacts. We curate the techniques and artifacts from the AI-augmented binary reversing literature rather than seeking to provide an exhaustive catalog. ModeAnalysis GoalRepresentative TechniquesAnalysis Artifacts TriageStructural analysis Binary profiling Binary header and import parsing, raw byte extraction String and statistical extraction Header, sections, imports, exports, byte Strings, constants, n-grams, histogram, entropy, provenance graph chi-square statistic Static Analysis Disassembly Function boundary recovery Control-flow analysis Call-site analysis IR lifting Data-flow analysis Pointer/alias analysis Static taint analysis Control-dependence analysis Data-dependence analysis Program-dependence analysis Stack-frame analysis Decompilation Linear and recursive sweep, superset disassembly Prologue and call-target heuristics Control-flow graph construction Direct call-site identification, indirect call resolution Instruction lifting, SSA conversion Reaching definitions, def-use linking Andersen’s and Steensgaard’s algorithm; Taint propagation Post-dominator computation Load-store dependence linking Dependence-graph merge, slicing Stack and frame pointer tracking Expression and AST reconstruction Assembly, instruction format fields Function boundaries CFG, IFG CG, ICFG IR DFG, def-use chains, memory-access facts Points-to relations, alias sets Tainted values (register, memory, callee argument) CDG, PDT DDG PDG Stack-frame layout (variable slots, offsets) Pseudocode, variable data layout, AST Dynamic Analysis Execution tracing Forced execution Behavioral monitoring Dynamic taint analysis Memory forensics Dynamic binary instrumentation Branch forcing, emulation API and system-call interception Shadow-memory tagging Process-memory dumping Instruction/memory-access trace, instruction address Memory-access/runtime-value trace, instruction address API/syscall/system event trace, source-sink map, provenance graph Taint trace, taint map Memory snapshot Security Testing Symbolic execution Fuzzing State forking, SMT solving Mutation and coverage feedback Symbolic state/constraint/expression, pre/post-state values Coverage map, mutated input IFG: instruction-flow graph; CFG: control-flow graph; CG: call graph; ICFG: inter-procedural control-flow graph; DFG: data-flow graph; CDG/DDG/PDG: control/data/program-dependence graph; PDT: post-dominator tree; AST: abstract syntax tree; IR: intermediate representation for subsequent dynamic analysis, security testing, and AI- augmented inference. However, their accuracy remains sub- ject to uncertainty arising from compiler optimizations, in- direct control flow, aliasing, and obfuscation. Dynamic Analysis. Dynamic analysis targets execution- dependent behaviors and properties that static analysis can- not fully resolve. Its techniques observe concrete executions, instrument runtime events, monitor interactions with the execution environment, and recover program state that mani- fests only during execution. The resulting evidence provides grounded behavioral insights by capturing what the binary actually does under specific inputs, states, and environmental conditions. These artifacts complement static artifacts by validating or contextualizing recovered semantics. However, their evidential scope is bounded by execution coverage and the inputs, states, and environments under which the binary is observed. Security Testing. Security testing is the intervention mode of the conventional reversing pipeline. It aims to ex- plore program behaviors, generate informative inputs, val- idate hypotheses, and stress semantic assumptions through controlled perturbations. Representative techniques actively steer execution through fuzzing, symbolic or concolic exe- cution, path exploration, or differential testing. The resulting artifacts capture exercised execution paths, generated inputs, solver-derived constraints, coverage information, failures, and validation outcomes. These artifacts allow hypotheses and interpretations derived from static and dynamic analysis to be validated against observed program behavior, yielding evidence-backed conclusions. Analysis Artifacts. The aforementioned four analysis modes produce a diverse set of analysis artifacts, which Table 3 organizes into eight classes: code, graphs, numerical statistics, binary facts, test sets, snapshots, logical expres- sions and text streams. This artifact layer constitutes the interface between conventional and AI-augmented reversing. Notably, rather than learning directly from reversing activ- ities, AI models operate on representations derived from these artifacts; consequently, artifact quality, fidelity, and provenance may directly influence downstream inference. 5. AI-Augmented Binary Reversing Table 7 in Appendix provides the complete per-study map- ping of artifact forms, representation steps, and learning paradigms; the following subsections abstract this inventory into the recurring stages of the AI-augmented pipeline. For brevity, we summarize representative examples from 80 top- venue studies (unless otherwise stated) for each stage of the pipeline: artifact forms and classes in Table 3, canonicaliza- tion techniques in Table 4, tokenization strategies in Table 5, encoding and embedding choices in Table 6. 5.1. Artifact Forms as Interface FeatureEngineeringforArtifact-to-DataConver- sion. From a traditional machine-learning perspective, fea- ture engineering is the process of constructing model- consumable features from raw data through feature extrac- tion, selection, transformation, and encoding. In the context Table 3: Analysis artifact classes and their common AI-consumable forms. Notably, the same artifact may be represented in different forms depending on the learning pipeline; for instance, bytes can be encoded as numeric descriptors, sequences, or images (§5.1). Representative artifacts and the corresponding surveyed papers are shown for each class. The symbols , ,, anddenote numeric descriptors, sequences, graphs, and images, respectively. Artifact ClassFormExamples Code RepresentationsInstruction format field [76]; assembly [77]–[85]; IR [77]–[79, 86, 87]; pseudocode [80] Byte [58, 88]–[92] assembly [79, 93]–[107]; IR [108]; pseudocode [12, 99, 109]–[115] Assembly [116]–[126]; IR [3, 110, 118, 125, 127, 128]; pseudocode [110, 126, 129] Text StreamsSystem event trace [130]; taint trace [87, 107]; string [80, 86, 87, 131]–[135] Instruction trace [136]–[138]; memory-access trace [100]; runtime-value trace [100, 136, 138]; API event trace [130, 139, 140]; system event trace [140, 141]; taint trace [87]; string [94, 125] Instruction trace [107, 122]; memory-access trace [107, 122]; runtime-value trace [107]; string [119] Binary FactsSymbolic state [142]; tainted value [78, 79]; import [78]–[80, 131]–[135, 143]; export [131, 133]–[135, 143]; header [131]–[135, 143]; section [131, 133]–[135, 143]; constant [78, 79, 86]; stack-frame layout [84, 86]; pre/post-state value [77]; source-sink record [144]; runtime-value state [145] Instruction address [100, 136]; constant [94]; stack-frame layout [109, 112] Header [116]; section [116]; import [116]; constant [119]; stack-frame layout [110, 121]; points-to relation [109, 121]; memory-access fact [128]; tainted value [125] Graph RepresentationsCFG [80, 83]; ICFG [77]–[79, 84, 85, 138]; CG [78, 86, 87]; AST [80]; def-use chain [86]; PDG [86]; CFG [89]; ICFG [98, 105]; CG [101, 114]; def-use chain [105]; provenance graph [146] CFG [93]–[95, 103, 108, 117]–[123, 126, 127]; DFG [109, 110, 121, 126]–[129]; CG [109, 110, 129]; def-use chain [109, 110, 118, 121, 125, 127]–[129]; PDG [86, 99]; DDG [3, 125]; ICFG [104, 116, 124, 125]; IFG [76]; AST [126] Numerical StatisticsEntropy [108, 131]–[135, 143]; histogram [131, 133]–[135]; chi-square statistic [141]; coverage map [147] Entropy [148]; coverage map [149] SnapshotsTaint map [145] Logical ExpressionsSymbolic expression [77, 107]; symbolic constraint [107] Test SetsMutated input [144] Mutated input [4, 5, 149, 150] Mutated input [150] of binary reversing, we use the term more broadly to en- compass the representation-preparation stages that transform binary-derived artifacts into learning-ready inputs. Artifact Forms. The first step in the AI-augmented binary reversing pipeline is to represent selected artifacts (Table 2) in model-consumable artifact forms. Such a representation choice is of significance because models cannot directly learn from raw artifacts. Table 3 shows the eight artifact classes (from the conventional reversing pipeline): code representations, graph representations, numerical statistics, binary facts, test sets, snapshots, logical expressions and text streams. Accordingly, we define four artifact forms that determine what aspects of the binary are exposed to a model: numeric descriptors, which encode compact ag- gregate information while sacrificing ordering or relational detail; sequences, which emphasize local order and token co- occurrence; graphs, which capture structural dependencies; and images. Notably, mappings between artifact classes and forms are many-to-many. For example, assembly and pseudocode may be summarized as numeric descriptors, linearized as token sequences, or transformed into relational structures such as control-flow, syntax, or data-flow graphs. Similarly, a CFG may be represented through numeric graph statistics, path- or walk-based sequences, or its native graph topology; whereas bytes may be represented as numeric values, sequences, or images. 5.2. Canonicalization and Tokenization 5.2.1. Canonicalization. After selecting analysis artifacts, prior work often applies canonicalization because raw ar- tifacts are often noisy, variable, and compiler-dependent. To reduce representation variability and improve learning robustness, we taxonomize canonicalization methodologies by artifact form. Value and Token Canonicalization. For numeric descrip- tors, canonicalization typically consists of feature-value scaling (e.g., min-max, Z-score, log scaling), which nor- malizes measurements to comparable ranges and prevents features with large magnitudes from dominating the learning process. For sequences, common techniques include 1to- ken abstraction, which replaces concrete registers, addresses, constants, function or jump targets, strings, or identifiers with canonical placeholders (e.g., eax → REG, 0x401000 → ADDR, printf→ FUNC, hello→ STR), and 2 token fil- tering, which removes task-irrelevant or redundant sequence elements. Such operations normalize low-level representa- tions by abstracting semantically equivalent elements and eliminating non-essential components. Structural and Visual Canonicalization. For graphs, canonicalization is more diverse and may involve node and edge attribute mapping, structural transformation (e.g., reshaping graph topology), and subgraph extraction. Such techniques standardize graph semantics, enrich or simplify graph structure, and isolate task-relevant regions while pre- serving essential program relationships. For images, canoni- Table 4: Canonicalization techniques by AI-consumable arti- fact form. Canonicalization determines which surface varia- tions in an artifact are preserved, scaled, replaced, removed, mapped, transformed, or extracted prior to learning (§5.2.1). This table summarizes canonicalization techniques applied to numeric descriptor, sequence, graph, and image forms. Form Canonicalization Techniques Feature value scaling [78, 79, 84, 85, 108, 131, 132, 134, 141, 143, 144]; feature value removal [76] Byte value scaling [4, 5, 136, 137]; abstraction by replacement [79, 95]–[98, 100, 109, 111]–[113, 138] [103]–[106, 108, 114, 140, 146]; filtering by removal [102, 108, 136, 139]–[141, 146] Structural transformation [109, 110, 116, 118, 121, 122, 127]–[129] [3, 104, 107, 124]–[126]; node attribute mapping [76, 86, 103, 108, 110, 118]–[120, 123, 126]; edge attribute mapping [76, 86, 110, 118]–[120, 123, 126]; subgraph extraction [3] Image size scaling [150]; pixel value scaling [150] Table 5: Tokenization taxonomy for sequence-based arti- facts. Tokenization defines how a sequence is partitioned into model-consumable units prior to encoding (§5.2.2). We classify tokenization strategies by split basis: atomic units, syntactic units, rule-based decomposition, and data-driven segmentation. This table summarizes popular tokenization techniques. Split BasisToken Units / Tokenization Strategies Atomic unitsByte [4, 5, 58, 88]–[92, 136, 137, 149]; character [94] Syntactic unitsInstruction/IR-level (e.g., opcode, operands) [98, 108, 136] [100, 104, 105]; whole instruction [95, 97, 99, 101, 102, 106, 138]; trace-level (e.g., events, offsets) [87, 130, 139, 141] Rule-based decomposition Custom rule (e.g., layout, entropy) [112, 146, 148, 150] Data-driven segmentation Subword (Byte Pair Encoding) [79, 93, 103, 107, 112, 113]; subword (Pretrained-LLM) [12, 96, 99, 109]–[111, 114] [115, 125, 140] calization primarily consists of image-size scaling and pixel- value scaling, which normalize spatial dimensions and inten- sity ranges to produce consistent visual inputs. Collectively, these procedures mitigate representation heterogeneity and incidental variation caused by compilation and artifact diver- sity, allowing learning algorithms to focus on task-relevant semantic patterns rather than superficial differences in arti- fact construction. 5.2.2. Tokenization. Tokenization is primarily applied to sequential forms, where raw sequences must be partitioned into discrete units before learning. Tokenization determines the basic units from which models learn and therefore plays a critical role in shaping (subsequent) representations. We taxonomize prior work according to four tokenization strate- gies: smallest observable symbols, language-defined sym- bols, manually decomposed symbols, statistically learned symbols. Atomic and Syntactic Units. First, atomic units treats the smallest observable symbols as tokens, such as individual bytes or characters. These approaches require minimal do- main knowledge and preserve the original representation at the finest granularity. Second, syntactic units leverages the syntactic structure of code and intermediate representations. Representative examples include treating entire instructions as tokens, separating opcodes and operands into individual elements, or using high-level-language lexer tokens. Rule-Based and Data-Driven Tokenization. Rule-based decomposition further partitions existing tokens accord- ing to manually specified rules. Examples include split- ting compound identifiers at naming-convention (i.e., camel- or snake-case) boundaries (e.g., GetProcAddress → Get, Proc, Address) or decomposing complex operands and expressions into finer-grained subtokens (e.g., mov eax, [ebx+4]→ mov, eax, [, ebx, +, 4, ]). Finally, data-driven segmentation learns token boundaries directly from large corpora. Representative techniques include byte- pair encoding (BPE), unigram language models, and tok- enizers inherited from pretrained LLMs, which construct subword vocabularies based on statistical regularities in the training data. Collectively, these strategies represent differ- ent tradeoffs among granularity, vocabulary size, seman- tic expressiveness, generalization ability, and reliance on domain-specific knowledge. 5.3. Encoding and Embedding Encoding. In our pipeline, encoding defines the fixed, non- learned interface that transforms model-consumable forms into concrete values that can be stored, batched, compared, or supplied to a model. We classify encodings by density: 1 sparse encodings preserve identity or membership through one-hot, multi-hot, token-, node-, and edge-ID, or adjacency indicators, whereas2dense encodings represent artifacts as compact numerical representations, including statistical vectors, graph matrices, time-series vectors, and pixel ten- sors. The choice depends on artifact form, as summarized in Table 6. Numeric descriptors are commonly encoded as one-hot or multi-hot categorical features, count or fre- quency vectors, or TF-IDF representations; sequences use token IDs, one-hot tokens, time-series vectors, or TF-IDF summaries; graphs use node and edge identifiers, feature mappings, and adjacency matrices; and images are encoded as dense pixel tensors. Embedding. Embedding denotes learned representations derived from encoded artifact forms during pretraining, fine-tuning, task training, or adaptation. Where encoding defines the numerical interface, embedding determines how the model organizes binary-derived evidence within a latent space for downstream reasoning, classification, retrieval, generation, or policy learning. As shown in Table 6, we classify embeddings by their use of neighboring context: 1context-independent embeddings represent a unit with little or no conditioning on its surrounding artifact con- text, as in lookup layers, word2vec/CBOW-style token em- beddings, PV-DM representations, local descriptor embed- dings, and bag-of-node graph summaries. In contrast, 2 Table 6: Encoding and embedding choices (§5.3) by model-consumable artifact form. Encoding is a fixed, non-learned conversion into model-readable values and is categorized (by density) as either sparse or dense. Embedding is a learned representation and is categorized (by context dependency) as either context-independent or context-dependent. This table summarizes various encoding and embedding strategies. Form Encoding Density Encoding Examples Embedding Method Embedding Examples SparseOne-hot [86]; multi-hot [81]Context- independent ResNet [108]; lookup layer [138]; LDP [78, 79]; BoostNE [78, 79]; Autoencoder [78, 79, 85] DenseCount vectors [80, 82, 84, 87, 132]; VLAD [83]; TF-IDF [80]; frequency vectors [80, 147] Context- dependent RNN [76]; CNN [87] SparseOne-hot [58, 88, 102, 137]Context- independent PV-DM [98, 146]; lookup layer [90]–[92]; CBOW [104]; CNN [136]; TextCNN [150]; Word2Vec [101]; MLP [4, 5] DenseTime-series vectors [148]; TF-IDF [104]Context- dependent Transformer-based [12, 89, 99, 100, 109, 111, 136] [105, 112, 114, 138, 140, 141]; Hierarchical BiLSTM [137] [94]; BERT-based [79, 88, 93, 99, 108, 113, 125] [95, 103, 105]; Hierarchical-LSTM [94]; Tree-LSTM [106]; Attention-based LSTM [107, 130]; Integer-LSTM [94]; LLM2Vec [96]; Word2Vec [97, 105]; Gated-CNN [139]; GRU [101, 105]; RNN-VAE [102]; RNN [89]; BiRNN [58] SparseNode attribute ID [86, 118]; edge attribute ID [86, 118, 122] Context- independent Bag-of-Nodes [3] DenseAdjacency matrix [3, 93, 99, 103, 104, 108, 123, 126]; node feature mapping [76, 94, 95, 108, 117, 119, 120, 127] [3, 104, 123, 126]; edge feature mapping [116, 121, 124, 127, 129]; Context- dependent GNN [117, 120]; GIN [103]; GCN [108]; RGCN [76, 127]; Bidirectional GGNN [118]; GGNN [94]; DeepWalk [104]; Graph2Vec [3]; BERT-based [99]; HMA-HMP [126]; Structure2Vec [95, 119, 123]; ResNet [93] DenseGrayscale tensor [150]Context- dependent CNN [150] BiLSTM: bidirectional long short-term memory; BiRNN: bidirectional recurrent neural network; BoostNE: boost network embedding; CBOW: continuous bag-of- words; CNN: convolutional neural network; GCN: graph convolutional network; GGNN: gated graph neural network; GIN: graph isomorphism network; GNN: graph neural network; GRU: gated recurrent unit; HMA-HMP: heterogeneous mutual attention-heterogeneous message passing; ID: identifier; LDP: local degree profile; LSTM: long short-term memory; MLP: multilayer perceptron; PV-DM: paragraph vector-distributed memory; RGCN: relational graph convolutional network; ResNet: residual neural network; RNN: recurrent neural network; RNN-VAE: RNN-based variational autoencoder; TextCNN: text convolutional neural network; TF-IDF: term frequency-inverse document frequency; VLAD: vector of locally aggregated descriptors context-dependent embeddings update the representation us- ing neighboring tokens, control- or data-flow neighbors, execution context, or spatial neighborhoods. Examples in- clude Transformer- and BERT-based sequence models RN- N/LSTM/GRU sequence encoders, graph neural or graph- embedding models and convolutional models operating on image or tensor representations. Notably, the embedding stage produces learned abstractions that directly condition the learning paradigms (§5.4). 5.4. Learning Paradigms Rule-Based Reasoning. We define a rule-based reasoning paradigm when inference over analysis artifacts is sym- bolic, probabilistic, or deductive rather than learned directly from data (e.g., end-to-end neural training). Early ML- driven binary reversing systems often rely on rule-based, solver-based, or probabilistic techniques when domains ex- hibit strong program-analysis invariants, such as calling conventions, symbolic equivalence, taint-propagation rules, type constraints, or consistency constraints across recovered entities. For instance, BinGo [77] uses symbolic execu- tion and SMT solving for cross-architecture binary code search; Debin [86] combines classical prediction with CRF- based structured inference for debug-information recovery; TaintInduce [145] learns boolean taint-propagation rules from execution observations; and Punstrip [151] performs CRF-based structural inference over function symbols. Later systems [121], [129] continue to employ this paradigm for structure, type, and signature recovery. Discriminative Learning. Discriminative learning maps artifact representations to bounded outputs such as labels, scores, rankings, pairwise matches, or cluster assignments. This is a dominating paradigm as in Table 1 when targets are verifiable. For example, code boundary detection classi- fies whether bytes or instructions correspond to valid code or function entry points [58], [88], [89]; code similarity detection learns embeddings or matching functions over functions, basic blocks, traces, or graphs [119], [152]–[154]; and malware, vulnerability, and provenance domains predict class labels, maliciousness, vulnerability relevance, or patch presence [90], [108], [132], [155]. Note that we include met- ric learning and contrastive learning because their learned representations ultimately support decision-oriented retrieval or matching. Generative Learning. Generative learning trains a model to produce artifact-like or analyst-facing outputs (e.g., names, summaries, source-like code) rather than selecting from a fixed output space. In our taxonomy, this paradigm appears frequently in domains where the desirable result is open-ended or textual, including function and variable name recovery [112], [114], [156], code summarization [105], [126], [157], and decompilation-oriented pseudocode gen- eration [106], [158]. Reinforcement Learning. Reinforcement learning applies when a reversing task is better formulated as sequential de- cision making under feedback than as direct label prediction. The learned object is a policy or value function that chooses actions, such as which symbolic state to explore, which features to retain, when to terminate dynamic analysis, or which fuzzing inputs to prioritize. For example, Wang et al [130] use actor-critic learning to decide emulation control during dynamic malware analysis; and DQFSA [159] adopts deep Q-learning for feature selection in malware detection. Coverage-guided fuzzing systems [5], [87], [147], [160] further demonstrate the role of reward signals, including coverage growth, crashes, and time-to-bug. LLM-based Fine-tuning. LLM-based fine-tuning is distin- guished from general generative learning because it starts from a pretrained language model and updates its parameters on binary-derived artifacts. This paradigm leverages broad code and language knowledge acquired during pretraining while specializing the model to assembly, IR, decompiler output, or domain-specific reversing tasks. Examples in- clude staged adaptation for function-name recovery [111], variable name generation framework [114], fine-tuning on assembly-source and decompiler-output pairs [161], and decoder-only foundation model for assembly-code repre- sentation and generation [71]. Unlike prompting-only sys- tems, the resulting behavior depends heavily on training data, adaptation objective, parameter-update strategy, and the quality of the fine-tuning corpus. LLM Prompting. LLM prompting uses a pretrained LLM as a fixed inference engine; no model parameters are updated for the target reversing task. Instead, binary-derived artifacts are textualized into prompts, potentially augmented with ex- amples, chain-of-thought instructions, tool outputs, retrieval context, or candidate lists. This paradigm is important be- cause recent LLM-based systems, including agentic systems, can perform classification, recovery, explanation, candidate selection, and hypothesis generation over heterogeneous artifacts without requiring task-specific training. Represen- tative examples include prompt-driven workflow for taint- oriented vulnerability analysis [162], LLM-based readability selection for recovered types and structures [110], and LLM- driven refinement of decompiler output for pseudocode re- covery [115]. However, the reproducibility of LLM prompt- ing depends heavily on prompt templates, context construc- tion, model version, decoding settings, and the quality of upstream analysis artifacts. 5.5. Evaluation Practices Evaluation Setup. Figure 2 summarizes the reported char- acteristics of evaluation setups along six independently nor- malized categories: target architecture, compiler, optimiza- tion level, reversing tool, software package, and binary format. Percentages are computed over reported occurrences rather than unique papers, binaries, or packages. For target architectures, x86-family binaries (x86-32 and x86-64) ac- count for approximately 70% of architecture occurrences, ICC MSVC Clang GCC Others O1 O2 O3 O0 BinaryNinjaa Radare2 angr Ghidra Others IDA Pro (Hex-Rays) PE ELF ELF + PE 100 75 50 25 0 Composition (%) ArchitecturesCompilers Optimization levels Others ARM-32 x86-32 x86-64 ARM-64 busybox (3.7%) diffutils zlib SQLite curl findutils binutils OpenSSL coreutils Others BusyBox Software packages Reversing tools Binary formats Figure 2: Approximate composition of the binary corpus in our paper collection. The figure illustrates the most com- monly reported architectures, compilers, optimization levels, reversing tools, software packages, and binary formats (top- k, withk ranging from 3 to 10). Percentages are calculated from all reported occurrences rather than unique entities; therefore, a single option (e.g., coreutils) contributes multi- ple counts. Note that each bar is independently normalized to 100% and may not reflect the full paper corpus. with ARM-family and other architectures comprising the remainder. Compiler usage is dominated by GCC and Clang, which together account for approximately 85% of compiler occurrences; MSVC, ICC, and other compilers constitute the rest. Optimization settings are heavily concentrated in standard optimization levels: O0-O3 account for more than 90% of their occurrences, whereas Os, Ofast, and other ap- pear far less frequently. Among reversing tools, IDA Pro and Hex-Rays (for decompilation) account for around 40% of tool occurrences, followed by Ghidra (12%), angr (9%), and smaller shares for Radare2, Binary Ninja, and other tools. The most frequently reported software packages include coreutils and OpenSSL (approximately 7% each), followed by binutils, findutils, diffutils, BusyBox, zlib, SQLite, curl, and others. For binary formats, ELF accounts for 70% of format occurrences, PE for 23%, and mixed ELF+PE or other formats for the remainder. Evaluation Metrics. We organize reported evaluation met- rics by output form: classification or detection labels, re- trieval rankings, generated text, and security-testing out- comes. Classification and detection systems primarily report label-agreement metrics, including F1 (64%), recall (59%), precision (58%), and accuracy (53%). Class-imbalanced set- tings additionally report metrics such as macro-F1 [163]– [165], while malware-drift evaluations report time-integrated variants such as Area Under Time [131], [134]. Retrieval and similarity systems mainly report ranking-oriented met- rics: Recall@K (32%), Top-K or rank (26%), MRR (23%), and Precision@K (19%) [83], [123], [152], [153]. Pairwise similarity formulations further report accuracy (42%) and ROC-AUC (35%). Generative systems for name recovery, summarization, and pseudocode generation use a broader metric portfolio, including precision (48%), recall (48%), F1 (44%), accuracy (28%), BLEU (24%), ROUGE (24%), exact match (20%), edit distance (16%), and embedding similarity (4%) [79], [138]. Decompilation and code-generation stud- ies also report functional correctness measures, including compilability, re-executability, pass rates, and human- or tool-assisted validation [71], [161]. Meanwhile, security- testing systems report operational metrics such as cover- age, newly reached paths, crashes or bugs found, solver cost, and time-to-bug/time-to-exposure [4], [5], [87], [147], [149], [160]. Recent LLM-based systems additionally em- ploy LLM-as-judge evaluation to assess generated sum- maries, recovered names, or code explanations [99], [114]. 6. Key Observations and Insights 6.1. RQ1: Landscape and Maturity Domain Imbalance. AI-augmented binary reversing spans a broad set of reversing domains, yet the landscape remains uneven. Progress focuses on domains that can be formulated as a classification, detection, or retrieval problem whose output is drawn from a fixed, well-defined space (59.8%). In such domains, predictions can often be validated directly against ground truth, which is typically easy to obtain, facilitating large-scale dataset construction, benchmarking, and model evaluation. Code boundary detection [76], [88], [89] and binary similarity [119], [152], [153] are the most settled, not because models have recovered broad program intent, but because they target narrowly defined outputs with tractable evaluation criteria. Recent trends have fo- cused more on generative models that assist in understand- ing program semantics. The recovery of lost information (23.5%), such as variable names, types, structures, function names, benefits from readily obtainable labels (e.g., debug information). Several systems [106], [115], [158], [161], [166] further extend reversing from artifact-level prediction to high-level pseudocode generation. However, the maturity of such systems is more difficult to assess, as their outputs are often underconstrained and inherently ambiguous. We revisit this gap as a validity risk in §6.2. Insight 1:AI-augmented binary reversing has achieved broad domain coverage but uneven maturity. Domains with stable labels and tractable evaluation criteria have matured, whereas generative semantic recovery remains less mature because its outputs are often underconstrained and vague to evaluate. Artifact Imbalance for Learning. The artifact forms are likewise imbalanced. Current AI-augmented reversing pri- marily learns from static artifacts because they are inex- pensive to collect, easy to batch, and available at corpus scale. As a result, raw bytes, assembly instructions, lifted IR, decompiled code, CFGs, and call graphs dominate many pipelines [88], [119], [152], [153], [161]. Meanwhile, dy- namic traces, memory snapshots, symbolic constraints, and generated tests provide more direct behavioral evidence; however, they are more difficult to collect and sensitive to execution coverage. This creates a structural bias: models often learn from artifacts that are easy to extract rather than from those that better capture the underlying code semantics. The bias is particularly detrimental for protected-code anal- ysis, unpacking, and deobfuscation, where static evidence may be incomplete, encrypted, generated at runtime, or intentionally misleading (e.g., anti-analysis techniques). Insight 2:The field’s learning artifacts are heavily skewed toward static representations, whereas behavior- grounded artifacts remain comparatively uncommon de- spite their significance for validating runtime and protected-code semantics. 6.2. RQ2: Validity Risks in AI-Driven Pipeline Unlike conventional reversing that reasons directly over analysis artifacts, AI-augmented reversing systems do not operate on binaries directly; they learn representations from those artifacts. This additional learning layer introduces new validity risks spanning datasets, artifacts, representations, models, and evaluations. 6.2.1. Corpus Validity. Since AI-augmented reversing learns from binary-derived artifacts, corpus construction constitutes a fundamental validity boundary. Corpus Monoculture. Despite the availability of bench- mark datasets [153], [167], most prior work relies on custom datasets, making direct performance comparisons difficult. Besides, evaluations repeatedly draw from similar package families, architectures, compilers, optimization settings, and build configurations, as shown in Figure 2. Such corpus monoculture (i.e., limited software diversity) may lead to a bias, constraining generalization to unfamiliar architectures, toolchains, formats, libraries, and deployment environments. Although increasingly large corpora have enabled pretrain- ing and generative models [67], [68], [70], the corpus scale alone does not guarantee semantic generalization across unseen samples. This is partly because real-world soft- ware often incorporates proprietary code, custom toolchains, vendor-specific modifications, third-party libraries, software protections, and deployment-specific configurations that are underrepresented in curated benchmark datasets. Insight 3:Corpora derived from limited open-source projects and controlled build environments may not fully represent deployed binaries. Consequently, corpus diver- sity is as critical as corpus scale for establishing semantic generalization beyond curated benchmarks. Leakage. Train–test leakage is a persistent threat to validity in AI-augmented reversing because binaries are derived from source code, different samples may still share identical or near-identical functions, libraries, templates, or compiler- generated code. As a result, binary- or function-level dataset splits may inadvertently contain duplicate or near-duplicate code in both the training and evaluation sets. Models may appear to generalize by memorizing recurring code patterns, leading to overly optimistic performance estimates. Several studies [138], [168], [169] have demonstrated such leakage. Insight 4: Train–test separation at the binary or function level does not necessarily prevent code overlap. Without careful deduplication and split construction, reported gains may reflect memorization of recurring code rather than genuine generalization. 6.2.2. Artifact and Ground-Truth Fidelity. Analysis ar- tifacts and ground-truth labels are indirect observations of program semantics, each introducing assumptions, inaccu- racies, and potential sources of bias. Proxy Ground Truth. Ground truth labels in binary re- versing are often proxies rather than direct measures of semantic truth, each encoding a particular notion of cor- rectness. The labels (e.g., debug symbols, compiler meta- data, decompiler outputs, curated malware labels) may con- tain inconsistencies, omissions, or task-specific assumptions. Compiler optimizations, such as function inlining [170], can eliminate the target function, complicating code-similarity analysis and vulnerability discovery. The malware analysis field often suffers from label-quality issues: a study [132] reports that a widely used malware-family dataset [171] con- tains approximately 40% label noise. Other works introduce preprocessing strategies to mitigate label noise and data sparsity [168], or reduce reliance on noisy labels through label-free representation learning [172]. Insight 5: AI-augmented reversing tasks often learn from proxy labels rather than direct semantic truth. Hence, the quality of the labels places an upper bound on the quality of the model. Dependence on Reversing Tools. AI models inherit the assumptions and failures of the reversing tools that produce their inputs. Function boundaries, call graphs, decompiler variables, lifted IR, and CFGs are often treated as stable model inputs, yet they are outputs of disassemblers, de- compilers, lifters, and tracers, which may contain errors. For example, prior work reports structural inconsistencies in widely used disassembly tools [89], while another study finds substantial discrepancies in function discovery across binary analysis tools [169]. At higher abstraction levels, incomplete control-flow recovery can propagate errors to downstream analyses [137], and decompiler outputs may constitute noisy approximations of the original source [173]. Several studies therefore employ multiple analysis tools to mitigate tool-specific limitations [129], while others reveal substantial variation across disassemblers, decompilers, and architectures in the artifacts they produce [113], [116]. Therefore, reported performance often reflects the combined behavior of the model and its upstream toolchain rather than the model alone. Insight 6: AI models inherit the strengths and weaknesses of the reversing tools. Tool-specific errors, abstractions, and unsupported cases can propagate throughout the learn- ing pipeline, making tool provenance an important factor in model validity. 6.2.3. Representation Validity. Representations are not neutral encodings of binary artifacts; they reflect design choices that determine which information is preserved, ab- stracted, or discarded before learning. Representation Misalignment. An artifact representation is not neutral preprocessing but a semantic commitment. Artifact selection decides which evidence a model can ob- serve, while canonicalization decides which differences are preserved, abstracted, or removed. These choices involve inherent tradeoffs. Coarse canonicalization may discard con- stants, offsets, calling-context cues, strings, or identifiers that certain tasks depend on, whereas fine-grained tok- enization increases vocabulary size and out-of-vocabulary rates. A recurring observation in the literature [67], [174] is the tradeoff between representation granularity and vo- cabulary size: instruction-level modeling sacrifices inter- nal instruction detail, whereas token-level modeling must cope with vocabulary growth. Importantly, more evidence does not necessarily yield better models. Several studies show that carefully selected or simplified representations can outperform richer alternatives. For example, one study demonstrates that binary-similarity models can improve ro- bustness by deliberately reducing reliance on control-flow- graph (CFG) structure [175]. Other work achieves strong performance using lightweight features alone [168], while several studies show that feature selection, weighting, or pruning can match or exceed the performance of full- feature representations [108], [159], [176]. Conversely, some domains benefit from combining complementary sources. Multi-graph fusion [177], embedding ensembles [79], and code-data-address fusion [136] all yield ablation-confirmed gains over individual representations. More recently, a com- parative study [178] demonstrates that a vanilla BERT model achieves performance comparable to, or better than, custom Transformer architectures across multiple downstream ap- plications. This apparent contradiction demonstrates a fun- damental gap between how we represent the binary and how it supports downstream tasks. The challenges of unifying the representations remains unsolved: no study establishes the minimal set of representations sufficient for a given reversing task, nor when additional evidence stops providing value. Insight 7: Feature engineering is a semantic commitment, not a neutral preprocessing step. The field lacks principled guidance on what information should be preserved, ab- stracted, or fused for a given task, leaving representation design largely empirical. 6.2.4. Model Validity. Model performance depends not only on the quality of the training dataset and its representa- tions, but also on architectural choices, training procedures, and hyperparameter settings. Design Choices Ablation. Typically, a learning model is governed by architectural choices and training proce- dures, which determine numerous hyperparameters, includ- ing learning rates, optimization schedules, embedding di- mensions, decision thresholds [179], beam widths, retrieval cutoffs, and other configuration settings [180], which can substantially affect both training stability and reported evalu- ation outcomes. This sensitivity poses a validity risk because performance improvements may arise from extensive hyper- parameter tuning rather than from the proposed methodol- ogy itself. The problem is particularly evident when com- parisons are made across studies that employ different ar- chitectures, training budgets, search strategies, or evaluation protocols. Moreover, hyperparameters optimized for one dataset or software ecosystem may not transfer to others, making it difficult to distinguish genuine methodological advances from configuration-specific gains. Consequently, reproducibility requires transparent reporting of tuning pro- cedures, search spaces, and sensitivity analyses rather than only the final configuration. Insight 8: Reported gains may reflect hyperparameter optimization as much as algorithmic improvement. With- out sensitivity analysis and transparent tuning procedures, it is difficult to separate methodological advances from configuration-specific effects. Model Robustness. Model robustness remains underchar- acterized both during training and after deployment. During training, robustness depends on ISA and platform diversity, compiler and optimization diversity, artifact perturbations, and exposure to adversarial, obfuscated, or otherwise chal- lenging samples [181]. Even when trained on the same corpus, learning outcomes may vary across random initial- izations, optimization trajectories, and training configura- tions. Such sensitivity can manifest as unstable performance across random seeds, overfitting to the training distribution, or shortcut learning, where a model relies on superficial statistical cues rather than the program semantics intended by the task. After deployment, models may face distribution shift arising from temporal drift, new tool versions, malware evolution, changed compiler idioms, shifts in target architec- tures, and unfamiliar execution environments. These shifts can alter both the observable artifacts and the relationship between artifacts and labels, degrading performance even when the target task is identical. Malware-drift studies [82], [131], [172] demonstrate that post-training degradation is not a minor edge case but a recurring deployment risk. One mitigation strategy [82], [131] is to exclude malware test samples associated with low-confidence predictions, thereby reducing the impact of uncertain classifications. Consequently, robustness should be evaluated as a dis- tributional property across time, toolchains, architectures, software ecosystems, and adversarial conditions, rather than solely through in-distribution test accuracy. Insight 9: Robustness extends beyond benchmark accu- racy. AI-augmented reversing systems must remain stable across training randomness and generalize across evolving ecosystems and threat landscapes. 6.2.5. Evaluation Validity. Performance relies on evalua- tion metrics; however, such metrics provide only indirect evidence of semantic recovery and may fail to capture behavioral correctness or analyst utility. Metric Validity. Performance in AI-augmented reversing is typically assessed through quantitative metrics such as accuracy, precision, recall, F1, AUC, MRR, Recall@k, BLEU, and ROUGE. These metrics are appropriate for detection, classification, retrieval, and generation tasks, yet they provide only indirect evidence of semantic recovery. A model may achieve high retrieval accuracy without im- proving analyst utility, high classification accuracy without capturing causal program behavior, or strong BLEU and ROUGE scores despite producing semantically incorrect decompilation output. Domain-specific evaluations partly address this limitation. Fuzzing systems [4], [5], [87], [147], [149], [160] report operational signals such as coverage, new paths, crashes, and time-to-bug. Similarly, generative systems increasingly report compilability, re-executability, pass rates, and human- or tool-assisted validation in addi- tion to lexical similarity metrics [105], [115], [126], [157], [161], [182]. Nevertheless, performance may still rely on thresholds, decision boundaries, prompts, decoding param- eters, and other evaluation choices. What remains largely missing is a consistent chain from model outputs to validated semantic correctness and practical reversing value. Insight 10: Evaluation metrics answer different questions and provide only indirect evidence of semantic recovery. The field still lacks a consistent link between benchmark performance and validated reversing value. 7. RQ3: Challenges and Future Directions CommonEvaluationFramework. ProgressinAI- augmentedreversingrequirestestbedsthatsupport fair, reproducible, and directly comparable evaluation across studies. Unlike conventional machine-learning benchmarks, binary-reversing datasets are produced through complex artifact-generation pipelines involving compilation, optimization, stripping, disassembly, lifting, decompilation, tracing, and other analysis stages. As a result, benchmark specifications should capture not only the underlying binary corpus but also build recipes, package provenance, architecture coverage, compiler versions, optimization levels, binary formats, software protections, reversing-tool versions, artifact-generation procedures, split policies, and duplicate-control rules. Equally important is the provenance of the artifacts consumed by downstream models. If a model relies on a disassembler’s function boundaries, a decompiler’s variables, a lifter’s IR, or a tracer’s events, those dependencies should be made explicit and evaluated separately from the model itself. Such testbeds would help distinguish gains arising from improved learning algorithms from gains attributable to corpus construction, artifact quality, tool selection, or evaluation methodology. The long-term goal is a reproducible evaluation framework in which models, artifacts, tools, and datasets can be compared under transparent and controlled conditions. Semantic Validation. Future AI-augmented reversing sys- tems should be able to validate their conclusions through the collective strength of evidence rather than relying solely on a single artifact, model prediction, or evaluation metric. Reverse-engineering tasks rarely provide direct access to semantic ground truth. Instead, confidence is often estab- lished by combining complementary evidence from static artifacts [183]–[185], dynamic traces [137], [138], [154], symbolic constraints [107], memory state [100], [145], execution-based tests [186], [187], external knowledge, and analyst feedback. Accordingly, conclusions should be ac- companied by explicit supporting evidence, including the artifacts, observations, and reasoning steps that justify them, together with any remaining uncertainty or conflicting ev- idence. The central challenge is to move beyond artifact- level agreement toward evidence-backed semantic claims whose validity can be independently assessed. The long- term objective is not merely to produce plausible outputs, but to establish trustworthy conclusions grounded in multi- ple supporting sources of evidence. Adversarial Robustness and Transfer. AI-augmented re- versing must generalize across architectures, compiler ver- sions, optimization levels, libraries, programming languages, toolchains, obfuscators, packers, and adversarial inputs. Fu- ture research should therefore evaluate transferability under realistic distribution shifts rather than relying solely on in- distribution train-test splits. The domains in which the target semantics are intentionally concealed or distorted are of particular importance. Despite their central role in practical reversing, the code restoration domain (D01 in Table 1) represents one of the largest gaps in the current research landscape including deobfuscation, unpacking, virtualized- code analysis, and other semantics-preserving code trans- formations. Advancing these domains will require models that remain robust when artifacts become incomplete, frag- mented, or deliberately misleading. Advanced Multimodal Semantic Reasoning. Future AI- augmented reversing systems should integrate multi- ple sources of evidence, including static artifacts, dy- namic traces, symbolic constraints, memory snapshots, and execution-based tests, while preserving their provenance and uncertainty. Each modality contributes a distinct view of program behavior: static analysis provides broad coverage of potential execution paths, dynamic analysis reveals concrete runtime behavior, symbolic reasoning exposes path condi- tions, memory snapshots capture execution state, and tests validate hypotheses through intervention. The challenge is therefore not simply to fuse more modalities, but to reason across them while maintaining traceability to the underlying evidence and communicating the confidence associated with each conclusion. Human feedback constitutes an additional source of evidence, incorporating higher-level semantic un- derstanding that may not be observable from individual artifacts alone. Goal-Driven Agentic Reasoning. As agentic AI becomes increasingly capable, binary reversing should transition from prompt-driven assistance toward goal-driven reason- ing; emerging systems [188]–[191] already point in this direction. Rather than responding to generic prompts, future systems should begin with an analyst’s objective, such as understanding malware behavior, validating a vulnerability, triaging a patch, recovering an input format, or explaining suspicious code. Achieving such objectives requires more than single-step prediction. An agent must plan and adapt its analysis, select appropriate tools and artifacts, acquire missing execution context, generate and rank competing hypotheses, and determine which claims require additional evidence or validation. The reasoning loop should remain explicit and evidence-driven: AI proposes, prioritizes, and synthesizes, while disassemblers, decompilers, debuggers, emulators, fuzzers, symbolic execution engines, tests, and human analysts provide grounding and verification. The central challenge is not merely autonomous tool use, but reliable goal-directed reasoning that can justify its conclu- sions, quantify uncertainty, and adapt its strategy as new evidence emerges. AI-Powered Autonomous Reversing Trajectory. The evo- lution from AI-augmented to AI-powered reversing should be viewed as an autonomy spectrum rather than a replace- ment of human analysts. Today, AI primarily assists individ- ual stages of the reversing flow, including artifact represen- tation, retrieval, classification, summarization, and prioriti- zation. More AI-powered workflows would coordinate mul- tiple stages end to end, selecting appropriate tools and arti- facts, generating and refining hypotheses, validating claims, and presenting evidence-backed conclusions together with calibrated uncertainty. In such workflows, human respon- sibilities would shift from performing routine analysis to- ward specifying objectives, exercising high-stakes judgment, defining validation criteria, and maintaining accountability. The open research challenge is determining which decisions can be delegated safely, which require explicit evidence, and where human review remains mandatory. 8. Concluding Remarks Binary reversing is a security-critical semantic inference problem under incomplete information, and plays a central role in software understanding. Recent advances in deep learning, LLMs, and agentic AI systems have emerged as powerful complementary approaches across a broad spec- trum of binary reversing domains. However, their rapid adoption has produced an increasingly fragmented body of research. This SoK presents the first comprehensive sys- tematization of AI-augmented binary reversing, covering 22 reversing domains across 144 papers. We introduce a uni- fied taxonomy that bridges conventional and AI-augmented binary reversing, treating analysis artifacts as the interface between reversing workflows and AI-driven inference. This artifact-centric perspective exposes a common workflow underlying seemingly disparate approaches and provides a framework for understanding and comparing AI-augmented reversing domains. Our study yields several key insights. The field has advanced substantially, yet its maturity remains uneven across domains, artifact representations, and learn- ing paradigms. The AI-augmented pipeline entails validity risks throughout the learning lifecycle, including corpus construction, ground-truth collection, artifact representation, model training, and evaluation. We hope that the common vocabulary, unified framework, and insights distilled in this SoK will help shape future directions and advance the development of reliable, scalable, and generalizable AI- augmented binary reversing systems. Disclosure of Generative AI Usage The authors used AI-based tools to assist with grammar cor- rection, language polishing, and readability improvements. In addition, generative AI tools were employed during the literature review process to help retrieve information from the collected papers according to the proposed taxonomy and identify potentially relevant content for further exami- nation. However, all AI-generated outputs were treated as auxiliary aids and manually verified against the original papers by the authors. Every technical claim, taxonomy design, categorization of prior work, trend analysis, synthe- sis of findings, and scientific conclusions were developed, reviewed, and approved by the authors, who take full respon- sibility for the accuracy and integrity of this manuscript. References [1]Y. Shoshitaishvili, R. Wang, C. Hauser, C. Kruegel, and G. Vigna, “Firmalice - automatic detection of authentication bypass vulnerabil- ities in binary firmware,” in Proceedings of the 22nd Annual Network and Distributed System Security Symposium (NDSS), 2015. [2]J. Zhao, Y. Li, Y. Zou, Z. Liang, Y. Xiao, Y. Li, B. Peng, N. Zhong, X. Wang, W. Wang et al., “Leveraging semantic relations in code and data to enhance taint analysis of embedded systems,” in Proceedings of the 33rd USENIX Security Symposium (Security), 2024. [3]M. Ahmadi, R. M. Farkhani, R. Williams, and L. Lu, “Finding bugs using your own code: detecting functionally-similar yet inconsistent code,” in Proceedings of the 30th USENIX Security Symposium (Security), 2021. [4]M. Wu, L. Jiang, J. Xiang, Y. Zhang, G. Yang, H. Ma, S. Nie, S. Wu, H. Cui, and L. Zhang, “Evaluating and improving neural program- smoothing-based fuzzing,” in Proceedings of the 44th IEEE/ACM International Conference on Software Engineering (ICSE), 2022. [5]D. She, R. Krishna, L. Yan, S. Jana, and B. Ray, “Mtfuzz: fuzzing with a multi-task neural network,” in Proceedings of the 28th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE), 2020. [6]C. Kolbitsch, T. Holz, C. Kruegel, and E. Kirda, “Inspector gadget: Automated extraction of proprietary gadgets from malware binaries,” in Proceedings of the 31st IEEE Symposium on Security and Privacy (SP), 2010. [7]P. M. Comparetti, G. Salvaneschi, E. Kirda, C. Kolbitsch, C. Kruegel, and S. Zanero, “Identifying dormant functionality in malware programs,” in Proceedings of the 31st IEEE Symposium on Security and Privacy (SP), 2010. [8]Z. Xu, A. Nappa, R. Baykov, G. Yang, J. Caballero, and G. Gu, “Autoprobe: Towards automatic active malicious server probing using dynamic binary analysis,” in Proceedings of the 21st ACM SIGSAC Conference on Computer and Communications Security (CCS), 2014. [9]J. Caballero, P. Poosankam, C. Kreibich, and D. Song, “Dispatcher: Enabling active botnet infiltration using automatic protocol reverse- engineering,” in Proceedings of the 16th ACM SIGSAC Conference on Computer and Communications Security (CCS), 2009. [10]R. A. See, M. Gehring, M. Fischer, and S. Karuppayah, “Binary sight-seeing: Accelerating reverse engineering via point-of-interest- beacons,” in Proceedings of the 39th Annual Computer Security Applications Conference (ACSAC), 2023. [11]B. Zhao, S. Ji, J. Xu, Y. Tian, Q. Wei, Q. Wang, C. Lyu, X. Zhang, C. Lin, J. Wu et al., “One bad apple spoils the barrel: Under- standing the security risks introduced by third-party components in iot firmware,” IEEE Transactions on Dependable and Secure Computing (TDSC), 2023. [12]L. Jiang, J. An, H. Huang, Q. Tang, S. Nie, S. Wu, and Y. Zhang, “Binaryai: Binary software composition analysis via intelligent bi- nary source code matching,” in Proceedings of the 46th IEEE/ACM International Conference on Software Engineering (ICSE), 2024. [13]H. Wu, J. Wu, R. Wu, A. Sharma, A. Machiry, and A. Bianchi, “Veribin: Adaptive verification of patches at the binary level.” in Proceedings of the 32nd Annual Network and Distributed System Security Symposium (NDSS), 2025. [14]H. Zhang and Z. Qian, “Precise and accurate patch presence test for binaries,” in Proceedings of the 27th USENIX Security Symposium (Security), 2018. [15]X. Xu, Q. Zheng, Z. Yan, M. Fan, A. Jia, Z. Zhou, H. Wang, and T. Liu, “Patchdiscovery: Patch presence test for identifying binary vulnerabilities based on key basic blocks,” IEEE Transactions on Software Engineering (TSE), 2023. [16]R. Duan, A. Bijlani, Y. Ji, O. Alrawi, Y. Xiong, M. Ike, B. Saltafor- maggio, and W. Lee, “Automating patching of vulnerable open- source software versions in application binaries.” in Proceedings of the 26th Annual Network and Distributed System Security Sympo- sium (NDSS), 2019. [17]N. A. Kraft, B. A. Malloy, and J. F. Power, “An infrastructure to support interoperability in reverse engineering,” Information and Software Technology, 2007. [18]—, “Toward an infrastructure to support interoperability in reverse engineering,” in Proceedings of the 12th Working Conference on Reverse Engineering (WCRE), 2005. [19]N. Lewis, A. Case, A. Ali-Gombe, and G. G. Richard I, “Memory forensics and the windows subsystem for linux,” Digital Investiga- tion, 2018. [20]R. D. Maggio, A. Case, A. Ali-Gombe, and G. G. Richard I, “Seance: Divination of tool-breaking changes in forensically impor- tant binaries,” Forensic Science International: Digital Investigation, 2021. [21]M. I. Cohen, “Characterization of the windows kernel version vari- ability for accurate memory analysis,” Digital Investigation, 2015. [22]S. Hand, Z. Lin, G. Gu, and B. Thuraisingham, “Bin-carver: Au- tomatic recovery of binary executable files,” Digital Investigation, 2012. [23]N. Rosenblum, X. Zhu, and B. P. Miller, “Who wrote this code? identifying the authors of program binaries,” in Proceedings of the 16th European Symposium on Research in Computer Security (ESORICS), 2011. [24]A. Caliskan, F. Yamaguchi, E. Dauber, R. Harang, K. Rieck, R. Greenstadt, and A. Narayanan, “When coding style survives com- pilation: De-anonymizing programmers from executable binaries,” in Proceedings of the 25th Annual Network and Distributed System Security Symposium (NDSS), 2018. [25]Z. Tian, Q. Zheng, T. Liu, M. Fan, E. Zhuang, and Z. Yang, “Soft- ware plagiarism detection with birthmarks based on dynamic key instruction sequences,” IEEE Transactions on Software Engineering (TSE), 2015. [26]R. Duan, A. Bijlani, M. Xu, T. Kim, and W. Lee, “Identifying open- source license violation and 1-day security risk at large scale,” in Proceedings of the 24th ACM SIGSAC Conference on Computer and Communications Security (CCS), 2017. [27]C. Cifuentes and V. Malhotra, “Binary translation: Static, dynamic, retargetable?” in Proceedings of the IEEE International Conference on Software Maintenance (ICSM), 1996. [28]G. Canfora, A. Cimitile, A. De Lucia, and G. A. Di Lucca, “De- composing legacy programs: A first step towards migrating to client– server platforms,” Journal of Systems and Software (JSS), 2000. [29]D. Fujiwara, N. Ishiura, R. Sakai, R. Aoki, and T. Ogawara, “Re- verse engineering from mainframe assembly to c codes in legacy migration,” in Proceedings of the 5th IIAI International Congress on Advanced Applied Informatics (IIAI-AAI), 2016. [30]B. David, E. Filiol, and K. Gallienne, “Structural analysis of binary executable headers for malware detection optimization,” Journal of Computer Virology and Hacking Techniques, 2017. [31]S. Kanj, G. Vila, and J. Pegueroles, “Automating the detection of evasive windows malware: An evaluated yara rule library for anti-vm and anti-sandbox techniques,” Journal of Cybersecurity and Privacy (JCP), 2026. [32]R. H. Mahdi and H. Trabelsi, “Detection of malware by using yara rules,” in Proceedings of the 21st International Multi-Conference on Systems, Signals & Devices (SSD), 2024. [33]F. Zatloukal and J. Znoj, “Malware detection based on multiple pe headers identification and optimization for specific types of files (jaec),” Journal of Advanced Engineering and Computation, 2017. [34]G. Balakrishnan and T. Reps, “Analyzing memory accesses in x86 executables,” in Proceedings of the 13th International Conference on Compiler Construction (C), 2004. [35]Y. Lin and D. Gao, “When function signature recovery meets compiler optimization,” in Proceedings of the 42nd IEEE Symposium on Security and Privacy (SP), 2021. [36]P. Muntean, M. Fischer, G. Tan, Z. Lin, J. Grossklags, and C. Eckert, “cfi: Type-assisted control flow integrity for x86-64 binaries,” in Proceedings of the 21th International Symposium on Research in Attacks, Intrusions, and Defenses (RAID), 2018. [37]I. Haller, A. Slowinska, and H. Bos, “Scalable data structure de- tection and classification for c/c++ binaries,” Empirical Software Engineering, 2016. [38]Q. Sang, Y. Wang, Y. Liu, X. Jia, T. Bao, and P. Su, “Airtaint: Making dynamic taint analysis faster and easier,” in Proceedings of the 45th IEEE Symposium on Security and Privacy (SP), 2024. [39]Y. Zhang, T. Liu, Y. Wang, Y. Qi, K. Ji, J. Tang, X. Wang, X. Li, and Z. Zuo, “Hardtaint: production-run dynamic taint analysis via selec- tive hardware tracing,” Proceedings of the ACM on Programming Languages (PACMPL), 2024. [40]M. F. Abdelwahed, M. M. Kamal, and S. G. Sayed, “Detecting malware activities with malpminer: A dynamic analysis approach,” IEEE Access, 2023. [41]S. K. Cha, T. Avgerinos, A. Rebert, and D. Brumley, “Unleashing mayhem on binary code,” in Proceedings of the 33rd IEEE Sympo- sium on Security and Privacy (SP), 2012. [42]D. Xu, J. Ming, and D. Wu, “Cryptographic function detection in obfuscated binaries via bit-precise symbolic loop mapping,” in Proceedings of the 38th IEEE Symposium on Security and Privacy (SP), 2017. [43]S. Poeplau and A. Francillon, “Symbolic execution with symcc: Don’t interpret, compile!” in Proceedings of the 29th USENIX Security Symposium (Security), 2020. [44]S. Tempel, T. Brandt, C. L ̈ "uth, C. Dietrich, and R. Drechsler, “Accurate and extensible symbolic execution of binary code based on formal isa semantics,” in Design, Automation, and Test in Europe (DATE), 2025. [45]C. Lyu, S. Ji, C. Zhang, Y. Li, W.-H. Lee, Y. Song, and R. Beyah, “Mopt: Optimized mutation scheduling for fuzzers,” in Proceedings of the 28th USENIX Security Symposium (Security), 2019. [46]C. Aschermann, S. Schumilo, T. Blazytko, R. Gawlik, and T. Holz, “Redqueen: Fuzzing with input-to-state correspondence.” in Pro- ceedings of the 26th Network and Distributed System Security Symposium (NDSS), 2019. [47]V.-T. Pham, M. B ̈ "ohme, and A. Roychoudhury, “Model-based whitebox fuzzing for program binaries,” in Proceedings of the 31st International Conference on Automated Software Engineering (ASE), 2016. [48]H. Huang, P. Yao, R. Wu, Q. Shi, and C. Zhang, “Pangolin: Incremental hybrid fuzzing with polyhedral path abstraction,” in Proceedings of the 41th IEEE Symposium on Security and Privacy (SP), 2020. [49]T. Liu, Z. Wang, Y. Zhang, Z. Liu, B. Fang, and Z. Pang, “Auto- mated vulnerability discovery system based on hybrid execution,” in Proceedings of the 7th International Conference on Data Science in Cyberspace (DSC), 2022. [50]N. S. A. (NSA), “Ghidra: Software reverse engineering (sre) suite of tools,” https://ghidra-sre.org/, 2019. [51]Hex-Rays, “Ida pro disassembler,” https://w.hex-rays.com/ products/ida/, 2022. [52]G. Balakrishnan, R. Gruian, T. Reps, and T. Teitelbaum, “Codesurfer/x86—a platform for analyzing x86 executables,” in Proceedings of the 14th International Conference on Compiler Construction (C), 2005. [53]Y. Shoshitaishvili, R. Wang, C. Salls, N. Stephens, M. Polino, A. Dutcher, J. Grosen, S. Feng, C. Hauser, C. Kruegel et al., “Sok:(state of) the art of war: Offensive techniques in binary anal- ysis,” in Proceedings of the 37th IEEE Symposium on Security and Privacy (SP), 2016. [54]T. Avgerinos, “Tie: Principled reverse engineering of types in bi- nary programs,” in Proceedings of the 18th Annual Network and Distributed System Security Symposium (NDSS), 2011. [55]A. Slowinska, T. Stancescu, and H. Bos, “Howard: A dynamic exca- vator for reverse engineering data structures.” in Proceedings of the 18th Annual Network and Distributed System Security Symposium (NDSS), 2011. [56]Z. Lin, X. Zhang, and D. Xu, “Automatic reverse engineering of data structures from binary execution,” in Proceedings of the 11th Annual Information Security Symposium, 2010. [57]Google, “Google scholar,” https://scholar.google.com/intl/en/scholar/ about.html, 2026. [58]E. C. R. Shin, D. Song, and R. Moazzezi, “Recognizing functions in binaries with neural networks,” in Proceedings of the 24th USENIX Security Symposium (Security), 2015. [59]I. U. Haq and J. Caballero, “A survey of binary code similarity,” ACM Computing Surveys (CSUR), 2021. [60]W. Shao, Q. Yang, X. Guo, and R. Cai, “A survey of available information recovery of binary programs based on machine learn- ing,” in Proceedings of the 5th International Conference on Artificial Intelligence and Big Data (ICAIBD), 2022. [61]J. Singh and J. Singh, “A survey on machine learning-based malware detection in executable files,” Journal of Systems Architecture (JSA), 2021. [62]Y. Song, D. Zhang, J. Wang, Y. Wang, Y. Wang, and P. Ding, “Application of deep learning in malware detection: a review,” Journal of Big Data, 2025. [63]A. Adhikari and P. Kulkarni, “Survey of techniques to detect com- mon weaknesses in program binaries,” Cyber Security and Applica- tions (CSA), 2025. [64]Z. Shen and S. Chen, “A survey of automatic software vulnerability detection, program repair, and defect prediction techniques,” Security and Communication Networks, 2020. [65]Y. He, J. Lou, Z. Qin, and K. Ren, “Finer: Enhancing state-of-the- art classifiers with feature attribution to facilitate security analysis,” in Proceedings of the 30th ACM SIGSAC Conference on Computer and Communications Security (CCS), 2023. [66]W. Guo, D. Mu, J. Xu, P. Su, G. Wang, and X. Xing, “Lemna: Ex- plaining deep learning based security applications,” in Proceedings of the 25th ACM SIGSAC Conference on Computer and Communi- cations Security (CCS), 2018. [67]X. Li, Y. Qu, and H. Yin, “Palmtree: Learning an assembly language model for instruction embedding,” in Proceedings of the 28th ACM SIGSAC Conference on Computer and Communications Security (CCS), 2021. [68]Z. Su, X. Xu, Z. Huang, Z. Zhang, Y. Ye, J. Huang, and X. Zhang, “Codeart: Better code models by attention regularization when sym- bols are lacking,” in Proceedings of the 32nd ACM International Conference on the Foundations of Software Engineering (FSE), 2024. [69]H. Wang, Z. Gao, C. Zhang, Z. Sha, M. Sun, Y. Zhou, W. Zhu, W. Sun, H. Qiu, and X. Xiao, “Clap: learning transferable binary code representations with natural language supervision,” in Pro- ceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA), 2024. [70]J. Xiong, G. Chen, K. Chen, H. Gao, S. Cheng, and W. Zhang, “Hext5: Unified pre-training for stripped binary code information inference,” in Proceedings of the 38th IEEE/ACM International Conference on Automated Software Engineering (ASE), 2023. [71]N. Jiang, C. Wang, K. Liu, X. Xu, L. Tan, X. Zhang, and P. Babkin, “Nova: Generative language models for assembly code with hier- archical attention and contrastive learning,” in Proceedings of the 13th International Conference on Learning Representations (ICLR), 2025. [72]A. T. Nguyen, F. Lu, G. L. Munoz, E. Raff, C. Nicholas, and J. Holt, “Out of distribution data detection using dropout bayesian neural networks,” in Proceedings of the 36th AAAI Conference on Artificial Intelligence (AAAI), 2022. [73]S. Thirumuruganathan, F. Deniz, I. Khalil, T. Yu, M. Nabeel, and M. Ouzzani, “Detecting and mitigating sampling bias in cyberse- curity with unlabeled data,” in Proceedings of the 33rd USENIX Security Symposium (Security), 2024. [74]L. Yang, W. Guo, Q. Hao, A. Ciptadi, A. Ahmadzadeh, X. Xing, and G. Wang, “Cade: Detecting and explaining concept drift samples for security applications,” in Proceedings of the 30th USENIX Security Symposium (Security), 2021. [75]S. Mohseni, S. Mohammadi, D. Tilwani, Y. Saxena, G. K. Ndawula, S. Vema, E. Raff, and M. Gaur, “Can llms obfuscate code? a systematic analysis of large language models into assembly code obfuscation,” in Proceedings of the 39th AAAI Conference on Arti- ficial Intelligence (AAAI), 2025. [76]S. Yu, Y. Qu, X. Hu, and H. Yin, “Deepdi: Learning a relational graph convolutional network model on instructions for fast and accurate disassembly,” in Proceedings of the 31st USENIX Security Symposium (Security), 2022. [77]M. Chandramohan, Y. Xue, Z. Xu, Y. Liu, C. Y. Cho, and H. B. K. Tan, “Bingo: Cross-architecture cross-os binary search,” in Pro- ceedings of the 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE), 2016. [78]J. Patrick-Evans, M. Dannehl, and J. Kinder, “Xfl: Naming functions in binaries with extreme multi-label learning,” in Proceedings of the 44th IEEE Symposium on Security and Privacy (SP), 2023. [79]T. Benoit, Y. Wang, M. Dannehl, and J. Kinder, “Blens: Contrastive captioning of binary functions using ensemble embedding,” in Pro- ceedings of the 34th USENIX Security Symposium (Security), 2025. [80]A. Caliskan, F. Yamaguchi, E. Dauber, R. E. Harang, K. Rieck, R. Greenstadt, and A. Narayanan, “When coding style survives com- pilation: De-anonymizing programmers from executable binaries,” in Proceedings of the 25th Annual Network and Distributed System Security Symposium (NDSS), 2018. [81]Y. Du, O. Alrawi, K. Snow, M. Antonakakis, and F. Monrose, “Improving security tasks using compiler provenance information recovered at the binary-level,” in Proceedings of the 30th ACM SIGSAC Conference on Computer and Communications Security (CCS), 2023. [82]R. Jordaney, K. Sharad, S. K. Dash, Z. Wang, D. Papini, I. Nouret- dinov, and L. Cavallaro, “Transcend: Detecting concept drift in malware classification models,” in Proceedings of the 26th USENIX Security Symposium (Security), 2017. [83]Q. Feng, R. Zhou, C. Xu, Y. Cheng, B. Testa, and H. Yin, “Scalable graph-based bug search for firmware images,” in Proceedings of the 23rd ACM SIGSAC Conference on Computer and Communications Security (CCS), 2016. [84]S. Eschweiler, K. Yakdan, E. Gerhards-Padilla et al., “Discovre: Efficient cross-architecture identification of bugs in binary code,” in Proceedings of the 23rd Annual Network and Distributed System Security Symposium (NDSS), 2016. [85]E. Downing, Y. Mirsky, K. Park, and W. Lee, “Deepreflect: Dis- covering malicious functionality through binary reconstruction,” in Proceedings of the 30th USENIX Security Symposium (Security), 2021. [86]J. He, P. Ivanov, P. Tsankov, V. Raychev, and M. Vechev, “Debin: Predicting debug information in stripped binaries,” in Proceedings of the 25th ACM SIGSAC Conference on Computer and Communi- cations Security (CCS), 2018. [87]J. Shi, Z. Wang, Z. Feng, Y. Lan, S. Qin, W. You, W. Zou, M. Payer, and C. Zhang, “Aifore: Smart fuzzing based on automatic input format reverse engineering,” in Proceedings of the 32nd USENIX Security Symposium (Security), 2023. [88]K. Pei, J. Guan, D. W. King, J. Yang, and S. Jana, “Xda: Accurate, robust disassembly with transfer learning,” in Proceedings of the 28th Annual Network and Distributed System Security Symposium (NDSS), 2021. [89]S. Qin, F. Yang, H. Wang, B. Zhang, Z. Gao, C. Zhang, and K. Chen, “Tady: A neural disassembler without structural constraint violations,” in Proceedings of the 34th USENIX Security Symposium (Security), 2025. [90]E. Raff, W. Fleshman, R. Zak, H. S. Anderson, B. Filar, and M. McLean, “Classifying sequences of extreme length with constant memory applied to malware detection,” in Proceedings of the 35th AAAI Conference on Artificial Intelligence (AAAI), 2021. [91]K. Lucas, S. Pai, W. Lin, L. Bauer, M. K. Reiter, and M. Sharif, “Ad- versarial training for raw-binary malware classifiers,” in Proceedings of the 32nd USENIX Security Symposium (Security), 2023. [92]K. Lucas, W. Lin, L. Bauer, M. K. Reiter, and M. Sharif, “Training robust ml-based raw-binary malware detectors in hours, not months,” in Proceedings of the 31st ACM SIGSAC Conference on Computer and Communications Security (CCS), 2024. [93]Z. Yu, R. Cao, Q. Tang, S. Nie, J. Huang, and S. Wu, “Order matters: Semantic-aware neural networks for binary code similarity detection,” in Proceedings of the 34th AAAI Conference on Artificial Intelligence (AAAI), 2020. [94]Z. Yu, W. Zheng, J. Wang, Q. Tang, S. Nie, and S. Wu, “Codecmr: Cross-modal retrieval for function-level binary source code match- ing,” in Proceedings of the 34th Annual Conference on Neural Information Processing Systems (NeurIPS), 2020. [95]W. K. Wong, H. Wang, Z. Li, and S. Wang, “Binaug: Enhancing binary similarity analysis with low-cost input repairing,” in Proceed- ings of the 46th IEEE/ACM International Conference on Software Engineering (ICSE), 2024. [96]L. Li, L. Song, S. Ding, B. C. Fung, and P. Charland, “Transforming generic coder llms to effective binary code embedding models for similarity detection,” in Proceedings of the 39th Annual Conference on Neural Information Processing Systems (NeurIPS), 2025. [97]F. Zuo, X. Li, P. Young, L. Luo, Q. Zeng, and Z. Zhang, “Neural machine translation inspired binary code similarity comparison be- yond function pairs,” in Proceedings of the 26th Annual Network and Distributed System Security Symposium (NDSS), 2019. [98]S. H. Ding, B. C. Fung, and P. Charland, “Asm2vec: Boosting static representation robustness for binary clone search against code obfuscation and compiler optimization,” in Proceedings of the 40th IEEE Symposium on Security and Privacy (SP), 2019. [99]Z. Su, X. Xu, Z. Huang, K. Zhang, and X. Zhang, “Source code foundation models are transferable binary analysis knowledge bases,” in Proceedings of the 38th Annual Conference on Neural Information Processing Systems (NeurIPS), 2024. [100] K. Pei, J. Guan, M. Broughton, Z. Chen, S. Yao, D. Williams- King, V. Ummadisetty, J. Yang, B. Ray, and S. Jana, “Stateformer: Fine-grained type recovery from binaries using generative state modeling,” in Proceedings of the 29th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE), 2021. [101] Z. L. Chua, S. Shen, P. Saxena, and Z. Liang, “Neural nets can learn function type signatures from binaries,” in Proceedings of the 26th USENIX Security Symposium (Security), 2017. [102] T. Le, T. Nguyen, T. Le, D. Phung, P. Montague, O. De Vel, and L. Qu, “Maximal divergence sequential autoencoder for binary soft- ware vulnerability detection,” in Proceedings of the 7th International Conference on Learning Representations (ICLR), 2019. [103] A. S. Li, A. Iyengar, A. Kundu, and E. Bertino, “Revisiting concept drift in windows malware detection: Adaptation to real drifted malware with minimal samples,” in Proceedings of the 32nd Annual Network and Distributed System Security Symposium (NDSS), 2025. [104] Y. Duan, X. Li, J. Wang, and H. Yin, “Deepbindiff: Learning program-wide code representations for binary diffing,” in Proceed- ings of the 27th Annual Network and Distributed System Security Symposium (NDSS), 2020. [105] Z. Song, J. Chen, and K. Zhang, “Bin2summary: Beyond function name prediction in stripped binaries with functionality-specific code embeddings,” Proceedings of the ACM on Software Engineering (PACMSE), 2024. [106] C. Fu, H. Chen, H. Liu, X. Chen, Y. Tian, F. Koushanfar, and J. Zhao, “Coda: An end-to-end neural program decompiler,” in Proceedings of the 33rd Annual Conference on Neural Information Processing Systems (NeurIPS), 2019. [107] Z. Liu, Y. Yuan, S. Wang, X. Xie, and L. Ma, “Decompiling x86 deep neural network executables,” in Proceedings of the 32nd USENIX Security Symposium (Security), 2023. [108] Z. Luo, P. Wang, B. Wang, Y. Tang, W. Xie, X. Zhou, D. Liu, and K. Lu, “Vulhawk: Cross-architecture vulnerability detection with entropy-based binary code search,” in Proceedings of the 30th An- nual Network and Distributed System Security Symposium (NDSS), 2023. [109] D. Xie, Z. Zhang, N. Jiang, X. Xu, L. Tan, and X. Zhang, “Resym: Harnessing llms to recover variable and data structure symbols from stripped binaries,” in Proceedings of the 31st ACM SIGSAC Confer- ence on Computer and Communications Security (CCS), 2024. [110] Y. Wang, R. Liang, Y. Li, P. Hu, K. Chen, and B. Zhang, “Typeforge: Synthesizing and selecting best-fit composite data types for stripped binaries,” in Proceedings of the 46th IEEE Symposium on Security and Privacy (SP), 2025. [111] L. Jiang, X. Jin, and Z. Lin, “Beyond classification: Inferring function names in stripped binaries via domain adapted llms,” in Proceedings of the 32nd Annual Network and Distributed System Security Symposium (NDSS), 2025. [112] Q. Chen, J. Lacomis, E. J. Schwartz, C. Le Goues, G. Neubig, and B. Vasilescu, “Augmenting decompiler output with learned variable names and types,” in Proceedings of the 31st USENIX Security Symposium (Security), 2022. [113] K. K. Pal, A. P. Bajaj, P. Banerjee, A. Dutcher, M. Nakamura, Z. L. Basque, H. Gupta, S. A. Sawant, U. Anantheswaran, Y. Shoshi- taishvili et al., “"len or index or count, anything but v1": Predicting variable names in decompilation output with transfer learning,” in Proceedings of the 45th IEEE Symposium on Security and Privacy (SP), 2024. [114] X. Xu, Z. Zhang, Z. Su, Z. Huang, S. Feng, Y. Ye, N. Jiang, D. Xie, S. Cheng, L. Tan et al., “Unleashing the power of generative model in recovering variable names from stripped binary,” in Proceedings of the 32nd Annual Network and Distributed System Security Sym- posium (NDSS), 2025. [115] P. Hu, R. Liang, and K. Chen, “Degpt: Optimizing decompiler output with llm,” in Proceedings of the 31st Annual Network and Distributed System Security Symposium (NDSS), 2024. [116] S. Kim, H. Kim, and S. K. Cha, “Funprobe: Probing functions from binary code through probabilistic analysis,” in Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ES- EC/FSE), 2023. [117] A. Jia, M. Fan, X. Xu, W. Jin, H. Wang, and T. Liu, “Cross- inlining binary function similarity detection,” in Proceedings of the 46th IEEE/ACM International Conference on Software Engineering (ICSE), 2024. [118] H. He, X. Lin, Z. Weng, R. Zhao, S. Gan, L. Chen, Y. Ji, J. Wang, and Z. Xue, “Code is not natural language: Unlock the power of semantics-oriented graph representation for binary code similarity detection,” in Proceedings of the 33rd USENIX Security Symposium (Security), 2024. [119] X. Xu, C. Liu, Q. Feng, H. Yin, L. Song, and D. Song, “Neural network-based graph embedding for cross-platform binary code similarity detection,” in Proceedings of the 24th ACM SIGSAC Con- ference on Computer and Communications Security (CCS), 2017. [120] Y. Li, C. Gu, T. Dullien, O. Vinyals, and P. Kohli, “Graph matching networks for learning the similarity of graph structured objects,” in Proceedings of the 36th International Conference on Machine Learning (ICML), 2019. [121] Z. Zhang, Y. Ye, W. You, G. Tao, W.-c. Lee, Y. Kwon, Y. Aafer, and X. Zhang, “Osprey: Recovery of variable and data structure via probabilistic analysis for stripped binary,” in Proceedings of the 42nd IEEE Symposium on Security and Privacy (SP), 2021. [122] M. Ghaffarinia and K. W. Hamlen, “Binary control-flow trimming,” in Proceedings of the 26th ACM SIGSAC Conference on Computer and Communications Security (CCS), 2019. [123] J. Gao, X. Yang, Y. Fu, Y. Jiang, H. Shi, and J. Sun, “Vulseeker-pro: Enhanced semantic learning based binary vulnerability seeker with emulation,” in Proceedings of the 26th ACM Joint European Soft- ware Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE), 2018. [124] B. Zhao, S. Ji, X. Zhang, Y. Tian, Q. Wang, Y. Pu, C. Lyu, and R. Beyah, “Uvscan: Detecting third-party component usage violations in iot firmware,” in Proceedings of the 32nd USENIX Security Symposium (Security), 2023. [125] Z. Gao, C. Zhang, H. Liu, W. Sun, Z. Tang, L. Jiang, J. Chen, and Y. Xie, “Faster and better: Detecting vulnerabilities in linux- based iot firmware with optimized reaching definition analysis,” in Proceedings of the 31st Annual Network and Distributed System Security Symposium (NDSS), 2024. [126] K. Zhu, Z. Tian, S. Wang, W. Chen, Z. Dong, M. Leng, and X. Mao, “Misum: Multi-modality heterogeneous code graph learning for multi-intent binary code summarization,” Proceedings of the ACM on Software Engineering (PACMSE), 2025. [127] C. Zhu, Z. Li, A. Xue, A. P. Bajaj, W. Gibbs, Y. Liu, R. Alur, T. Bao, H. Dai, A. Doupé et al., “Tygr: Type inference on stripped binaries using graph neural networks,” in Proceedings of the 33rd USENIX Security Symposium (Security), 2024. [128] J. Bosamiya, M. Woo, and B. Parno, “Trex: Practical type recon- struction for binary code,” in Proceedings of the 34th USENIX Security Symposium (Security), 2025. [129] H. Huang, Y. Liu, Y. Cheng, H. Wei, J. Liu, Y. Wang, and L. Wang, “Recover function signature from combined constraints,” in Pro- ceedings of the 32nd ACM SIGSAC Conference on Computer and Communications Security (CCS), 2025. [130] Y. Wang, J. Stokes, and M. Marinescu, “Actor critic deep reinforce- ment learning for neural malware control,” in Proceedings of the 34th AAAI Conference on Artificial Intelligence (AAAI), 2020. [131] F. Barbero, F. Pendlebury, F. Pierazzi, and L. Cavallaro, “Tran- scending transcend: Revisiting malware classification in the presence of concept drift,” in Proceedings of the 43rd IEEE Symposium on Security and Privacy (SP), 2022. [132] X. Wu, W. Guo, J. Yan, B. Coskun, and X. Xing, “From grim reality to practical solution: Malware classification in real-world noise,” in Proceedings of the 44th IEEE Symposium on Security and Privacy (SP), 2023. [133] B. G. Doan, S. Yang, P. Montague, O. De Vel, T. Abraham, S. Camtepe, S. S. Kanhere, E. Abbasnejad, and D. C. Ranashinghe, “Feature-space bayesian adversarial learning improved malware de- tector robustness,” in Proceedings of the 37th AAAI Conference on Artificial Intelligence (AAAI), 2023. [134] J. Tian, W. Kong, D. Gao, T. Wang, T. Gu, K. Qiu, Z. Wang, and X. Kuang, “Density boosts everything: A one-stop strategy for improving performance, robustness, and sustainability of malware detectors,” in Proceedings of the 32nd Annual Network and Dis- tributed System Security Symposium (NDSS), 2025. [135] D. G. Corlatescu, A. Dinu, M. P. Gaman, and P. Sumedrea, “Em- bersim: A large-scale databank for boosting similarity search in malware analysis,” in Proceedings of the 37th Annual Conference on Neural Information Processing Systems (NeurIPS), 2023. [136] K. Pei, D. She, M. Wang, S. Geng, Z. Xuan, Y. David, J. Yang, S. Jana, and B. Ray, “Neudep: Neural binary memory dependence analysis,” in Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE), 2022. [137] W. Guo, D. Mu, X. Xing, M. Du, and D. Song, “Deepvsa: Facilitat- ing value-set analysis with deep learning for postmortem program analysis,” in Proceedings of the 28th USENIX Security Symposium (Security), 2019. [138] X. Jin, K. Pei, J. Y. Won, and Z. Lin, “Symlm: Predicting function names in stripped binaries via context-sensitive execution-aware code embeddings,” in Proceedings of the 29th ACM SIGSAC Con- ference on Computer and Communications Security (CCS), 2022. [139] Z. Zhang, P. Qi, and W. Wang, “Dynamic malware analysis with feature engineering and feature learning,” in Proceedings of the 34th AAAI Conference on Artificial Intelligence (AAAI), 2020. [140] C. Zhou, Y. Liu, W. Meng, S. Tao, W. Tian, F. Yao, X. Li, T. Han, B. Chen, and H. Yang, “Srdc: Semantics-based ransomware detec- tion and classification with llm-assisted pre-training,” in Proceedings of the 39th AAAI Conference on Artificial Intelligence (AAAI), 2025. [141] L. Zhao, Y. Zhang, Z. Wang, F. Yuan, and R. Hou, “Erw-radar: An adaptive detection system against evasive ransomware by contextual behavior detection and fine-grained content analysis,” in Proceed- ings of the 32nd Annual Network and Distributed System Security Symposium (NDSS), 2025. [142] J. He, G. Sivanrupan, P. Tsankov, and M. Vechev, “Learning to explore paths for symbolic execution,” in Proceedings of the 28th ACM SIGSAC Conference on Computer and Communications Secu- rity (CCS), 2021. [143] J. Park, A. Ji, M. Park, M. S. Rahman, and S. E. Oh, “Malcl: Leveraging gan-based generative replay to combat catastrophic for- getting in malware classification,” in Proceedings of the 39th AAAI Conference on Artificial Intelligence (AAAI), 2025. [144] D. She, Y. Chen, A. Shah, B. Ray, and S. Jana, “Neutaint: Efficient dynamic taint analysis with neural networks,” in Proceedings of the 41st IEEE Symposium on Security and Privacy (SP), 2020. [145] Z. L. Chua, Y. Wang, T. Baluta, P. Saxena, Z. Liang, and P. Su, “One engine to serve’em all: Inferring taint rules without architec- tural semantics,” in Proceedings of the 26th Annual Network and Distributed System Security Symposium (NDSS), 2019. [146] Q. Wang, W. U. Hassan, D. Li, K. Jee, X. Yu, K. Zou, J. Rhee, Z. Chen, W. Cheng, C. A. Gunter et al., “You are what you do: Hunting stealthy malware via data provenance analysis,” in Proceedings of the 27th Annual Network and Distributed System Security Symposium (NDSS), 2020. [147] M. Böhme, V.-T. Pham, and A. Roychoudhury, “Coverage-based greybox fuzzing as markov chain,” in Proceedings of the 23rd ACM SIGSAC Conference on Computer and Communications Security (CCS), 2016. [148] D. Gibert, C. Mateu, J. Planes, and R. Vicens, “Classification of malware by using structural entropy on convolutional neural net- works,” in Proceedings of the 32nd AAAI Conference on Artificial Intelligence (AAAI), 2018. [149] D. She, K. Pei, D. Epstein, J. Yang, B. Ray, and S. Jana, “Neuzz: Efficient fuzzing with neural program smoothing,” in Proceedings of the 40th IEEE Symposium on Security and Privacy (SP), 2019. [150] X. Wang, T. Hui, L. Zhao, and Y. Cheng, “Input-driven dynamic program debloating for code-reuse attack mitigation,” in Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ES- EC/FSE), 2023. [151] J. Patrick-Evans, L. Cavallaro, and J. Kinder, “Probabilistic naming of functions in stripped binaries,” in Proceedings of the 36th Annual Computer Security Applications Conference (ACSAC), 2020. [152] L. Massarelli, G. A. Di Luna, F. Petroni, R. Baldoni, and L. Quer- zoni, “Safe: Self-attentive function embeddings for binary simi- larity,” in Proceedings of the 16th International Conference on Detection of Intrusions and Malware, and Vulnerability Assessment (DIMVA), 2019. [153] H. Wang, W. Qu, G. Katz, W. Zhu, Z. Gao, H. Qiu, J. Zhuge, and C. Zhang, “Jtrans: Jump-aware transformer for binary code similarity detection,” in Proceedings of the 31st ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA), 2022. [154] K. Pei, Z. Xuan, J. Yang, S. Jana, and B. Ray, “Learning approximate execution semantics from traces for binary function similarity,” IEEE Transactions on Software Engineering (TSE), 2022. [155] G. Wu and H. Tang, “Binary code vulnerability detection based on multi-level feature fusion,” IEEE Access, 2023. [156] J. Lacomis, P. Yin, E. Schwartz, M. Allamanis, C. Le Goues, G. Neu- big, and B. Vasilescu, “Dire: A neural approach to decompiled identifier naming,” in Proceedings of the 34th IEEE International Conference on Automated Software Engineering (ASE), 2019. [157] A. Al-Kaswan, T. Ahmed, M. Izadi, A. A. Sawant, P. Devanbu, and A. van Deursen, “Extending source code pre-trained language models to summarise decompiled binaries,” in Proceedings of the 30th IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER), 2023. [158] D. S. Katz, J. Ruchti, and E. Schulte, “Using recurrent neural networks for decompilation,” in Proceedings of the IEEE 25th In- ternational Conference on Software Analysis, Evolution and Reengi- neering (SANER), 2018. [159] Z. Fang, J. Wang, J. Geng, and X. Kan, “Feature selection for malware detection based on reinforcement learning,” IEEE Access, 2019. [160] Y. Li, S. Ji, C. Lyu, Y. Chen, J. Chen, Q. Gu, C. Wu, and R. Beyah, “V-fuzz: Vulnerability prediction-assisted evolutionary fuzzing for binary programs,” IEEE Transactions on Cybernetics, 2020. [161] H. Tan, Q. Luo, J. Li, and Y. Zhang, “Llm4decompile: Decompiling binary code with large language models,” in Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), 2024. [162] P. Liu, C. Sun, Y. Zheng, X. Feng, C. Qin, Y. Wang, Z. Xu, Z. Li, P. Di, Y. Jiang, and L. Sun, “Llm-powered static binary taint analysis,” ACM Transactions on Software Engineering and Methodology (TOSEM), 2025. [163] D. Gibert, C. Mateu, J. Planes, and R. Vicens, “Using convolutional neural networks for classification of malware represented as images,” Journal of Computer Virology and Hacking Techniques, 2019. [164] G. Xiao, J. Li, Y. Chen, and K. Li, “Malfcs: An effective malware classification framework with automated feature extraction based on deep convolutional neural networks,” Journal of Parallel and Distributed Computing, 2020. [165] T. Benoit, J.-Y. Marion, and S. Bardin, “Binary level toolchain provenance identification with graph neural networks,” in Proceed- ings of the 28th IEEE International Conference on Software Anal- ysis, Evolution and Reengineering (SANER), 2021. [166] R. Liang, Y. Cao, P. Hu, and K. Chen, “Neutron: an attention-based neural decompiler,” Cybersecurity, 2021. [167] D. Kim, E. Kim, S. K. Cha, S. Son, and Y. Kim, “Revisiting binary code similarity analysis using interpretable feature engineering and lessons learned,” IEEE Transactions on Software Engineering (TSE), 2022. [168] H. Gao, S. Cheng, Y. Xue, and W. Zhang, “A lightweight frame- work for function name reassignment based on large-scale stripped binaries,” in Proceedings of the 30th ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA), 2021. [169] H. Koo, S. Park, and T. Kim, “A look back on a function identifica- tion problem,” in Proceedings of the 37th Annual Computer Security Applications Conference (ACSAC), 2021, p. 158–168. [170] O. Abusabha, J. Uhm, T. Abuhmed, and H. Koo, “A deep dive into function inlining and its security implications for ml-based binary analysis,” in Proceedings of the 32nd Annual Network and Distributed System Security Symposium (NDSS), 2025. [171] R. J. Joyce, D. Amlani, C. Nicholas, and E. Raff, “Motif: A malware reference dataset with ground truth family labels,” Computers & Security, 2023. [172] M. Dib, S. Torabi, E. Bou-Harb, N. Bouguila, and C. Assi, “Evoliot: A self-supervised contrastive learning framework for detecting and characterizing evolving iot malware variants,” in Proceedings of the 17th ACM Asia Conference on Computer and Communications Security (ASIA CCS), 2022. [173] A. Jaffe, J. Lacomis, E. J. Schwartz, C. Le Goues, and B. Vasilescu, “Meaningful variable names for decompiled code: A machine trans- lation approach,” in Proceedings of the 26th Conference on Program Comprehension (ICPC), 2018. [174] H. Kim, J. Bak, K. Cho, and H. Koo, “A transformer-based function symbol name inference model from an assembly language for binary reversing,” in Proceedings of the 18th ACM Asia Conference on Computer and Communications Security (ASIA CCS), 2023. [175] J. Wang, C. Zhang, L. Chen, Y. Rong, Y. Wu, H. Wang, W. Tan, Q. Li, and Z. Li, “Improving ml-based binary function similarity de- tection by assessing and deprioritizing control flow graph features,” in Proceedings of the 33rd USENIX Security Symposium (Security), 2024. [176] M. Ahmadi, D. Ulyanov, S. Semenov, M. Trofimov, and G. Giacinto, “Novel feature extraction, selection and fusion for effective malware family classification,” in Proceedings of the 6th ACM Conference on Data and Application Security and Privacy (CODASPY), 2016. [177] Y. Guo, P. Li, Y. Luo, X. Wang, and Z. Wang, “Exploring gnn based program embedding technologies for binary related tasks,” in Proceedings of the 30th IEEE/ACM International Conference on Program Comprehension (ICPC), 2022. [178] X. Li, L. Gao, S. Yu, Y. Qu, and H. Yin, “On the effectiveness of custom transformers for binary analysis,” in Proceedings of the 21th International Symposium on Research in Attacks, Intrusions, and Defenses (RAID), 2025. [179] S. Ahn, S. Ahn, H. Koo, and Y. Paek, “Practical binary code similarity detection with bert-based transferable similarity learning,” in Proceedings of the 38th Annual Computer Security Applications Conference (ACSAC), 2022. [180] G. Kim, S. Hong, M. Franz, and D. Song, “Improving cross-platform binary analysis using representation learning via graph alignment,” in Proceedings of the 31st ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA), 2022. [181] J. Uhm, M. Kim, M. Polychronakis, and H. Koo, “Fool me if you can: On the robustness of binary code similarity detection mod- els against semantics-preserving transformations,” arXiv preprint arXiv:2602.12681, 2026. [182] T. Ye, L. Wu, T. Ma, X. Zhang, Y. Du, P. Liu, S. Ji, and W. Wang, “Cp-bcs: Binary code summarization guided by control flow graph and pseudo code,” in Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), 2023. [183] P. Liu, Y. Zheng, C. Sun, C. Qin, D. Fang, M. Liu, and L. Sun, “Fits: Inferring intermediate taint sources for effective vulnerability analysis of iot device firmware,” in Proceedings of the 28th ACM International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS), 2023. [184] S. Yang, L. Cheng, Y. Zeng, Z. Lang, H. Zhu, and Z. Shi, “Asteria: Deep learning-based ast-encoding for cross-platform binary code similarity detection,” in Proceedings of the 51st IEEE/IFIP Inter- national Conference on Dependable Systems and Networks (DSN), 2021. [185] Z. Xu, C. Wen, and S. Qin, “Type learning for binaries and its applications,” IEEE Transactions on Reliability, 2018. [186] W. Huang and J. W. Stokes, “Mtnet: a multi-task neural network for dynamic malware classification,” in Proceedings of the 13th International Conference on Detection of Intrusions and Malware, and Vulnerability Assessment (DIMVA), 2016. [187] S. Yoo, S. Kim, S. Kim, and B. B. Kang, “Ai-hydra: Advanced hybrid approach using random forest and deep learning for malware classification,” Information Sciences, 2021. [188] X. Chen, A. Zhou, C. Ye, and C. Zhang, “Clearagent: Agentic binary analysis for effective vulnerability detection,” in Proceedings of the 1st ACM SIGPLAN International Workshop on Language Models and Programming Languages (LMPL), 2025. [189] H. Lee, J. Kim, and L. Zhang, “Agentic vulnerability reasoning on windows com binaries,” arXiv preprint arXiv:2605.05000, 2026. [190] X. Zhang, Q. Li, and H. Wang, “Feedback-driven execution for llm- based binary analysis,” arXiv preprint arXiv:2604.15136, 2026. [191] S. Radey, J. West, and K. Fawaz, “Challenges and future di- rections in agentic reverse engineering systems,” arXiv preprint arXiv:2604.14317, 2026. Appendix Figure 3: Snapshot of our interactive visualization platform for AI-augmented binary reversing pipelines. The left panel groups papers by reversing domain, while the main panel summarizes a selected study across the pipeline stages: artifact selection (i.e., analysis mode, artifact class and form), canonicalization, tokenization, encoding, embedding, learning, and inference. Each color denotes a model-consumable artifact form, and its connections indicate the flow across subsequent stages. Clicking a box displays additional information if available. Table 7: Proposed AI-augmented binary reversing pipeline via analysis artifacts, as observed across 80 top-venue papers. For each study, this table summarizes how its analysis artifacts traverse the pipeline, including artifact class (form) canonicalization, tokenization, encoding, embedding, and learning paradigm (§5.1- §5.4). Notably, different artifact forms (Table 3) follow distinct canonicalization, tokenization, encoding, and embedding pathways. Within a cell, semicolons (;) separate multiple model inputs and em dashes (—) indicate information unavailable. The symbols a ⃝, s ⃝, r ⃝, and d ⃝ denote atomic, syntactic, rule-based, and data-driven tokenization, respectively (Table 5); ,, and✗ denote context-dependent, context-independent, and absent embeddings, respectively (Table 6). At the embedding stage, → denotes sequential embedding, where a later embedding is initialized from a preceding one, whereas ∥ denotes embedding concatenation. DIDStudyArtifact form (Artifact class)Canonicalization (Tokenization)Encoding (Embedding)Learning D02Shin et al. [58](Code)— ( a ⃝)Sparse ()Discriminative XDA [88] (Code)— ( a ⃝)Sparse ()Discriminative DeepDi [76](Code);(Graph)Remove; mapDense ()→ Dense ()Discriminative FunProbe [116](BinFact, Code, Graph)TransformDense (✗)Rule-based Tady [89](Code);(Graph)— ( a ⃝); —Sparse ()→ Dense ()Discriminative D03TAINTINDUCE [145](BinFact, Snapshot)—Dense (✗)Rule-based DEEPVSA [137](TextStream)Scale ( a ⃝)Sparse ()Discriminative Neutaint [144](BinFact, TestSet)ScaleDense (✗)Discriminative NeuDep [136](TextStream),(BinFact),(TextStream)Remove ( s ⃝), scale ( a ⃝), scale ( a ⃝)Sparse ()∥ Dense ()∥ Dense ()Discriminative D05Gemini [119](Code, Graph, TextStream, BinFact)MapDense ()Discriminative Li et al. [120](Code, Graph)MapDense ()Discriminative INNEREYE [97] (Code)Replace ( s ⃝)Sparse ()Discriminative Asm2Vec [98](Code, Graph)Replace ( s ⃝)Sparse ()Discriminative CI-Detector [117](Code, Graph)—Dense ()Discriminative HermesSim [118](Code, Graph)Map, transformSparse ()Discriminative EBM [96](Code)Replace ( d ⃝)Sparse ()LLM-based BINGO [77](BinFact, Code, Graph, LogicExp)—Sparse (✗)Rule-based OrderMatters [93](Code);(Graph)— ( d ⃝); —Sparse ()→ Dense ()Discriminative BINAUG [95](Code);(Graph)Replace ( s ⃝); —Sparse ()→ Dense ()Discriminative BinaryAI [12](Code)— ( d ⃝)Sparse ()LLM-based CodeCMR [94] (Code);(Graph);(TextStream);(BinFact)—; —; — ( a ⃝); — (Sparse ()→ Dense ())∥ Sparse ()∥ Sparse () Discriminative D06Learch [142](BinFact)—Dense (✗)Discriminative D07OSPREY [121](BinFact, Code, Graph)TransformDense (✗)Rule-based ReSym [109] (BinFact, Code);(BinFact, Code);(BinFact, Graph);Replace ( d ⃝); Replace ( d ⃝); TransformSparse ()∥ Sparse (); Dense (✗) LLM-based; Rule-based TypeForge [110](BinFact, Code, Graph);(Code)Map, transform; — ( d ⃝)Dense (✗); Sparse ()Rule-based; LLM-based D08TYGR [127](Code, Graph)TransformSparse ()Discriminative TRex [128](BinFact, Code, Graph)TransformDense (✗)Rule-based StateFormer [100](BinFact, Code, TextStream);(Code)Replace ( s ⃝); Replace ( s ⃝)Sparse ()→ Sparse ()Discriminative D09EKLAVYA [101](Code, Graph);(Code)— ( s ⃝); — ( s ⃝)Sparse ()→ Sparse ()Discriminative CDA [129](Code, Graph)TransformDense (✗)Rule-based D10XFL [78](Graph);(Graph);(BinFact, Code)—; —; Scale(Dense ()∥ Dense ())→ Dense ()Discriminative SYMGEN [111](Code)Replace ( d ⃝)Sparse ()LLM-based SymLM [138](TextStream);(Graph)Replace ( s ⃝); —Sparse ()∥ Dense ()Discriminative BLens [79](Code);(Code);(BinFact, Code, Graph)Replace ( d ⃝); Replace ( d ⃝); ScaleSparse ()∥ Sparse ()∥ Dense ()Generative D11VARBERT [113](Code)Replace ( d ⃝)Sparse ()Discriminative Debin [86](BinFact, Code, Graph, TextStream);(Graph)—; MapSparse (✗); Sparse (✗)Discriminative; Rule-based DIRTY [112](Code);(BinFact)Replace ( d ⃝); Replace ( r ⃝)Sparse ()∥ Sparse ()Generative GENNM [114](Code, Graph)Replace ( d ⃝)Sparse ()LLM-based D12Caliskan et al. [80] (BinFact, Code, TextStream);(Graph); (Code);(Graph) —; —; —; — Dense (✗)∥ Dense (✗)∥ Dense (✗)∥ Dense (✗) Discriminative D13Du et al. [81](Code)—Sparse ()Discriminative D14Transcend [82](Code)—Dense (✗)Discriminative DeepReflect [85](Code, Graph)ScaleDense ()Discriminative Gibert et al. [148](Numeric)— ( r ⃝)Dense (✗)Discriminative MORSE [132](BinFact, Numeric, TextStream)ScaleDense (✗)Discriminative EMBERSim [135](BinFact, Numeric, TextStream)—Dense (✗)Discriminative MalCL [143](Numeric, BinFact)ScaleDense (✗)Discriminative D15CCFG [122](Code, Graph, TextStream)TransformSparse (✗)Discriminative Picup [150](TestSet);(TestSet)Scale; — ( r ⃝)Dense ()∥ Dense ()Discriminative D16Genius [83](Code, Graph)—Dense (✗)Discriminative discovRE [84](BinFact, Code, Graph)ScaleDense (✗)Discriminative Vulseeker-pro [123] (Code, Graph)MapDense ()Discriminative MDSAE [102](Code)Remove ( s ⃝)Sparse ()Discriminative VulHawk [108](Code); (Graph);(Numeric);Replace, remove ( s ⃝); Map; Scale(Sparse ()→ Dense ())→ Dense ()Discriminative D17Yu Wang et al. [130](TextStream);(TextStream)— ( s ⃝); —Sparse (); Sparse (✗)Discriminative; Reinforcement TRANSCENDENT [131](BinFact, Numeric, TextStream)ScaleDense (✗)Discriminative Zhang et al. [139] (TextStream)Remove ( s ⃝)Dense ()Discriminative PROVDETECTOR [146](Graph)Remove, replace ( r ⃝)Sparse ()Discriminative MalConv2 [90](Code)— ( a ⃝)Sparse ()Discriminative Greedy [91](Code)— ( a ⃝)Sparse ()Discriminative GreedyBlock [92](Code)— ( a ⃝)Sparse ()Discriminative Shuai Li et al. [103](Code);(Graph)Replace ( d ⃝), MapSparse ()→ Dense ()Discriminative SRDC [140](TextStream)Replace, remove ( d ⃝)Sparse ()Discriminative ERW-Radar [141](TextStream);(Numeric)Remove ( s ⃝); ScaleSparse (); Dense (✗)Discriminative SCB [134](BinFact, Numeric, TextStream)ScaleDense (✗)Discriminative Adv-MalBayes [133](BinFact, Numeric, TextStream)—Dense (✗)Discriminative D18DEEPBINDIFF [104](Code);(Graph)Replace ( s ⃝); TransformDense ()→ Dense ()Discriminative D19AFLFast [147](Numeric)—Dense (✗)Rule-based NEUZZ [149](Numeric, TestSet)— ( a ⃝)Dense (✗)Discriminative MTFuzz [5](TestSet)Scale ( a ⃝)Dense ()Discriminative FICS [3](Code, Graph);(Code, Graph)Extract, transform; Extract, transformDense ()→ Dense ()Discriminative PreFuzz [4](TestSet)Scale ( a ⃝)Dense ()Discriminative UVSCAN [124](Code, Graph)TransformDense (✗)Rule-based AIFORE [87](TextStream);(Code, Graph, TextStream)— ( s ⃝); —Sparse (✗); Dense ()Rule-based; Discriminative HermeScan [125](TextStream);(BinFact, Code, Graph)— ( d ⃝); TransformSparse (); — (✗)Discriminative D21Bin2Summary [105](Code, Graph)Replace ( s ⃝)Sparse ()Generative MiSum [126](Code, Graph)Map, transformDense ()Generative ProRec [99](Code);(Graph);(Code)— ( s ⃝); —; — ( d ⃝)Sparse ()∥ Dense (); Sparse ()Generative; LLM-based D22DeGPT [115](Code)— ( d ⃝)Sparse (✗)LLM-based Coda [106](Code)Replace ( s ⃝)Sparse ()Generative BTD [107] (Code);(TextStream);(LogicExp, TextStream)— ( d ⃝); Transform; —Sparse (); Dense (✗); Dense (✗)Discriminative; Rule-based BinFact: binary fact; Code: code representation; Extract: subgraph extraction; Graph: graph representation; LogicExp: logical expression; Map: node or edge attribute mapping; Numeric: numerical statistic; Remove: filtering by removal; Replace: abstraction by replacement; Scale: feature value scaling, byte value scaling, pixel value scaling, or image size scaling; Transform: structural transformation