Pith. sign in

REVIEW 3 major objections 7 minor 60 references

Guaranteed Guess: A Language Modeling Approach for CISC-to-RISC Transpilation with Testing Guarantees

T0 review · 3 major / 7 minor · reviewed 2026-08-15 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read A 1.5B-parameter language model, trained on paired x86/ARM assembly and validated by unit tests, transpiles CISC to RISC with 99.39% test-pass accuracy on HumanEval and beats Rosetta 2 on speed, energy, and memory.

desk verdict First LLM CISC-to-RISC transpiler with test-driven validation shows strong -O0 accuracy, but the Rosetta 2 comparison is not checkable and one citation looks fabricated. read the letter →

arxiv 2506.14606 v1 pith:NZPNJO23 submitted 2025-06-17 cs.CL cs.ARcs.LGcs.PLcs.SE

Ahmed Heakl , Sarim Hashmi , Chaimaa Abi , Celine Lee , Abdulrahman Mahmoud This is my paper · ORCID
classification cs.CLcs.ARcs.LGcs.PLcs.SE
keywords CISC-to-RISCtranspilationassemblylanguagemodeltest-drivenvalidationx86toARMtranslationRosetta2comparisoncodecoveragetokenizerextensionLLMbinary
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper claims that a small, custom-trained language model can translate x86 (CISC) assembly directly into ARM and RISC-V (RISC) assembly, and that plugging the output into a software-testing harness converts an unverifiable guess into a checked result. On the 164 HumanEval-C programs compiled at -O0, the flagship 1.5B model's most-likely output passes every unit test in 99.39% of ARMv8 translations and 89.93% of RISC-V64 translations; on the 65 full-program BringUpBench tasks it passes 49.23%. The same transpiled binaries run 1.73x faster, consume 1.47x less energy, and use 2.41x less memory than Apple's Rosetta 2 on an M2 Pro. If true, the result offers a different route across the x86-to-ARM migration problem: a one-time, test-checked translation instead of a persistent runtime translation layer.

What carries the argument

The load-bearing object is the GG pipeline itself: a 'guesser' — a custom-trained 1.5B-parameter decoder-only language model — that proposes ARM or RISC-V assembly from x86 assembly, followed by a validator that compiles, links, and runs the candidate against the target program's unit tests with gcov line coverage. The guesser's accuracy comes from four compounding components the paper ablates: training on paired assembly compiled from AnghaBench and The Stack v2, RoPE-based context extrapolation, a tokenizer extended with common opcodes and register names, and 8-beam search. The validator fixes the meaning of 'guaranteed': only a candidate that passes all tests counts as correct, and coverage above 98% gives the test run evidential weight.

What would settle it

Fuzz-test a GG-transpiled program that passes all provided HumanEval or BringUpBench tests with inputs outside the suite; any failing assertion would demonstrate that the 'guarantee' is test coverage, not semantic equivalence. Alternatively, re-run the Rosetta comparison on a published, representative workload list; if the 1.73x speedup does not survive, the efficiency claim is workload-specific.

Watch

Extended reading notes

Core claim

GG (Guaranteed Guess) is presented as the first CISC-to-RISC transpiler built by training a language model on paired assembly: roughly 1.31M C/C++ programs were compiled to x86 and to ARMv5, ARMv8, and RISC-V64 under -O0 and -O2, and the model was fine-tuned with a tokenizer extended for opcodes and registers, RoPE extrapolation to a 32.7k-token context, and 8-beam deterministic decoding. The central claim is that these choices make a 1.5B-parameter model accurate enough at unoptimized x86-to-ARM translation to pass complete unit-test suites in 99.39% of cases, far above general-purpose language models, and that the resulting native binaries are competitive with native compilation and beat the Rosetta 2 translation layer on runtime, energy, and memory. The 'guarantee' the authors claim is explicitly test-driven: a translation is counted correct only if every unit test passes, with line coverage above 98%, and the authors state in their limitations that this is not a proof of full semantic equivalence.

Load-bearing premise

The guarantee is only as strong as the unit tests: if the test suite fails to exercise some input or behavior, a GG translation that passes all tests can still be functionally wrong.

Editorial extensions

If this is right

  • GG's transpiled binaries run natively, so the per-execution overhead of dynamic translation disappears; the paper measures execution time matching native binaries and faster than Rosetta 2.
  • The test-driven guarantee means the method can be deployed wherever a program already has a meaningful test suite: passing it is a practical correctness certificate, not a proof of equivalence.
  • The method transfers to other RISC targets: the same training recipe reaches 89.93% on RISC-V64, showing the approach is not ARM-specific.
  • The model is small enough and quantizable enough (INT4 with less than 4% accuracy loss) that the authors propose deployment on edge devices as a realistic use case.
  • Accuracy drops sharply on -O2 binaries (45.12% on ARMv8), so the current guarantee is effectively limited to unoptimized code; the paper points to richer representations as the path to fix this.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The unit-test signal could be turned into an iterative repair loop: when a candidate fails a test, the failure is a concrete reward for resampling or patching, a direction the paper only hints at under 'test-driven transpilation and iterative repair'.
  • The same data-generation recipe — compile a corpus under two ISAs and train a small model — could produce transpilers for other pairs, such as ARM-to-RISC-V or x86-to-RISC-V with different optimization flags, with effort allocated by ISA similarity.
  • A natural next artifact would be a public, fixed workload suite for x86-to-ARM migration, so transpilers, emulators, and Rosetta-style layers can be compared on equal footing.
  • The similarity gradient across target ISAs suggests a cheap a priori predictor: compute an assembly-level similarity score between source and target ISA before investing in training data, and expect accuracy to track it.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 7 minor

Summary. The manuscript introduces Guaranteed Guess (GG), an assembly-to-assembly transpilation pipeline that fine-tunes small language models (Qwen2.5-Coder and DeepSeek-Coder variants) to translate x86 assembly into ARMv5, ARMv8, and RISC-V64 assembly. Training data are generated by compiling C/C++ programs from AnghaBench and The Stack v2 at -O0 and -O2, with additional components including an assembly-aware tokenizer extension, RoPE extrapolation, and beam search. Evaluation compiles the predicted assembly, links it with unit tests, and requires all tests to pass; the paper reports 99.39% pass@1 on HumanEval-C for ARMv8 at -O0, 45.12% at -O2, 89.63% on RISC-V64, and 49.23% on BringUpBench. A case study on Apple M2 Pro claims that GG-transpiled code is 1.73x faster, 1.47x more energy-efficient, and 2.41x more memory-efficient than Rosetta 2, with near-native performance. The paper also presents ablations, error analyses, and a similarity analysis across ISAs.

Significance. If the claims hold, this is a meaningful advance in LLM-based ISA transpilation. The work demonstrates that domain-adapted small models can vastly outperform general-purpose LLMs on a difficult low-level code task, and the test-driven evaluation protocol is a practical step beyond token-level metrics. The training and evaluation are not circular: correctness is determined by external unit tests rather than by similarity to training pairs. The paper also includes useful ablations, failure-mode taxonomies, and examples of syntactically different but functionally equivalent translations. However, the headline Rosetta 2 efficiency comparison currently lacks the experimental detail needed for independent verification, and the motivating scenario of translating legacy binaries is not directly evaluated.

major comments (3)
  1. [§5.2, Figure 3] The Rosetta 2 comparison is not reproducible as reported. The paper does not state which benchmark programs were measured, how many there were, how the x86 binaries for Rosetta were produced (including the compiler optimization level), whether the GG input was compiler-generated assembly or disassembled machine code, or what linking/runtime environment was used. This matters directly because GG's own accuracy drops from 99.39% at -O0 to 45.12% at -O2 on ARMv8 HumanEval (Table 3); an optimization-level mismatch could explain or even reverse the reported runtime, energy, and memory differences. The geometric means are reported without confidence intervals or per-program results, so a single outlier workload could drive the aggregate. Please disclose the full workload list, compilation flags, measurement protocol, and per-program measurements, and rerun the comparison under matched optimization levels.
  2. [§1 and §3.1] The paper frames GG as supporting 'legacy binaries' and 'binary-to-binary translation' without decompilation, but the actual pipeline is trained and evaluated on compiler-generated assembly produced from C/C++ source, not on disassembled or stripped binaries. No experiment demonstrates that the model can consume raw x86 machine code or a disassembly of such a binary as input. This is a load-bearing gap because the motivating application is migration of binaries whose source is unavailable. Please add an evaluation on disassembled or stripped binaries, or substantially revise the claims about legacy-binary support.
  3. [§5.1, Table 3; §5.4, Table 5] Several key numerical claims are presented without variance or significance information. HumanEval contains only 164 programs, so the differences between some ablations (e.g., +1.04% from the tokenizer extension and +1.21% from beam search in Table 5) correspond to roughly one or two programs. Without multiple training seeds or confidence intervals, the relative contributions of the components in Table 5 should be treated as unstable. Please report confidence intervals, bootstrap estimates, or repeated runs with different random seeds for the main accuracy claims and ablations.
minor comments (7)
  1. [Abstract] The abstract reports '99%' and '49%' while the body reports 99.39% and 49.23%; please use consistent rounded or exact values.
  2. [Figure 3] The figure shows only geometric means without per-program points or error bars; adding a scatter or box plot would make the comparison substantially more informative.
  3. [Table 5 caption] The caption says 'ARMv8 accuracy' but does not state the benchmark (presumably HumanEval) or optimization level; please specify the exact evaluation setting.
  4. [§4.1] The phrase '36x requests per second' is unclear; please specify the baseline for the '36x' improvement or report an absolute throughput value.
  5. [§4.2] There is a typo: 'as shown inf figure 1' should be 'as shown in Figure 1'.
  6. [Table 8] The table contains the typo 'Groud truth' instead of 'Ground truth'.
  7. [§5.1] The sentence 'This result is 9% lower than ARMv8 which shows how much different RISC-v64 from x86 compared ARMv8' is grammatically unclear and should be rewritten.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity; central accuracy claims rest on external unit tests and Rosetta, with only a non-load-bearing self-citation.

full rationale

GG's accuracy claims are evaluated by compiling generated ARM assembly, linking it with external unit tests from HumanEval-C and BringUpBench, and requiring all tests to pass in a strict pass@1 setting on the most probable sample. The training labels are compiler-generated (x86, ARM) pairs from AnghaBench and Stack-v2; the test suites are behavioral checks external to those training pairs and are not used to construct the training labels. No equation in the paper defines the reported accuracy in terms of the model's own training objective or output distribution, so the 99.39% and 49.23% results are genuine out-of-sample empirical measurements rather than identities. The Rosetta 2 comparison is an external empirical benchmark; the missing workload list, compiler flags, and variance details are reproducibility and correctness-risk weaknesses, not circularity. The only same-author citation is Guess & Sketch, but it is not load-bearing: the paper explicitly positions GG as an alternative ('instead of fixing transpilations with symbolic approaches, as done in Guess & Sketch') and does not rely on that prior work to justify any central claim. The limitations section also honestly concedes that unit-test success does not ensure full semantic equivalence, which further confirms that the testing guarantee is not being presented as a formal derivation from the model's inputs. Therefore, no circular step is present.

Assumptions & free parameters 3 free parameters · 4 assumptions · 0 invented entities

The central results rest on three kinds of assumptions: correctness of the compilation pipeline, sufficiency of the unit-test criterion, and representativeness of the benchmarks and workloads. None of these is independently verified, and the last is explicitly undisclosed.

free parameters (3)
  • Context window token length = 16k (RoPE extrapolated to 32.7k)
    Chosen via hyperparameter experiments on a 500k-sample subset; ablation shows a +1.76% accuracy gain from extrapolation.
  • Beam size = 8
    Selected after observing diminishing returns beyond 4 beams; adds +1.21% accuracy in ablation.
  • Training data size = 1.31M samples
    Scaled from 500k; ablation shows 93.94% accuracy at 1M AnghaBench, rising to 95.38% with Stackv2 added.
assumptions (4)
  • domain assumption The compilation of C/C++ programs to x86 and ARM/RISC-V assembly produces semantically equivalent paired training examples.
    Training relies on the correctness of both compilers and the pairing (Section 3.1). If the toolchains miscompile, the model learns wrong mappings.
  • domain assumption Passing the provided unit tests in HumanEval-C and BringUpBench is sufficient evidence of functional correctness for the entire transpiled program.
    The 'guarantee' claim rests on test coverage; Section 7 states the guarantee is bounded by the quality and coverage of the unit tests.
  • domain assumption The selected workloads for the Rosetta 2 comparison are representative of real-world x86-to-ARM translation tasks.
    Section 5.2 reports performance without specifying the programs used, so the 1.73x speedup assumes representativeness.
  • domain assumption Fine-tuning on the AnghaBench/Stack mixture transfers to the HumanEval-C and BringUpBench distributions.
    Generalization is assumed, not proven; no distribution-shift analysis is provided.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Guaranteed Guess: A Language Modeling Approach for CISC-to-RISC Transpilation with Testing Guarantees." pith.science (2026). https://pith.science/paper/NZPNJO23

@misc{pith2026250614606,
  author       = {Pith},
  title        = {Pith review of: Guaranteed Guess: A Language Modeling Approach for CISC-to-RISC Transpilation with Testing Guarantees},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/NZPNJO23}},
  note         = {Machine review of arXiv:2506.14606}
}
read the original abstract

The hardware ecosystem is rapidly evolving, with increasing interest in translating low-level programs across different instruction set architectures (ISAs) in a quick, flexible, and correct way to enhance the portability and longevity of existing code. A particularly challenging class of this transpilation problem is translating between complex- (CISC) and reduced- (RISC) hardware architectures, due to fundamental differences in instruction complexity, memory models, and execution paradigms. In this work, we introduce GG (Guaranteed Guess), an ISA-centric transpilation pipeline that combines the translation power of pre-trained large language models (LLMs) with the rigor of established software testing constructs. Our method generates candidate translations using an LLM from one ISA to another, and embeds such translations within a software-testing framework to build quantifiable confidence in the translation. We evaluate our GG approach over two diverse datasets, enforce high code coverage (>98%) across unit tests, and achieve functional/semantic correctness of 99% on HumanEval programs and 49% on BringupBench programs, respectively. Further, we compare our approach to the state-of-the-art Rosetta 2 framework on Apple Silicon, showcasing 1.73x faster runtime performance, 1.47x better energy efficiency, and 2.41x better memory usage for our transpiled code, demonstrating the effectiveness of GG for real-world CISC-to-RISC translation tasks. We will open-source our codes, data, models, and benchmarks to establish a common foundation for ISA-level code translation research.

Figures

Figures reproduced from arXiv: 2506.14606 by the authors.

Figure 1
Figure 1. GG System Overview. A two-stage transpilation pipeline from x86 to ARM/RISC-V. Left: Data is sourced from Stackv2 and AnghaBench, deduplicated, and compiled using both GCC and Clang to generate paired assembly (x86 ↔ ARM) from C/C++. Right: A specialized LLM (GG Guesser), trained with tokenizer extension and inferenced with RoPE extrapolation, predicts target ISA code. Predictions are evaluated via unit tests and sy… view at source ↗
Figure 2
Figure 2. Token counts by ISA and benchmark; BringUpBench is substantially longer than HumanEval. internal libraries and cross-linked components. This setup more accurately reflects real-world embedded systems development, where executing even a single file often requires compiling and linking the entire codebase. As a result, BringUpBench imposes sig￾nificantly greater context length demands. On aver￾age, each BringUpBench s… view at source ↗
Figure 3
Figure 3. Comparison of execution time, energy consumption, and memory usage across Rosetta, [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: Side-by-side comparison of opcode shift and CHRF similarity in ARM assembly analysis. [PITH_FULL_IMAGE:figures/full_fig_p008_4.png]
Figure 5
Figure 5. Figure 5: Impact of scaling and quantization on Qwen2.5-Coder 1.5B variant evaluated using the code coverage metric on HumanEval with -O0 compiler optimization. A Appendix A.1 Extra Data Analysis Scaling and quantization effect on Qwen2.5- coder models [PITH_FULL_IMAGE:figures/…

Review history (2 revisions) →

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

60 extracted references · 35 canonical work pages

  1. [1]

    Apple Inc. 2020. https://support.apple.com/en-us/HT211861 Apple’s rosetta 2 overview . Accessed: 2024-10-31

    work page 2020

  2. [2]

    Jordi Armengol-Estapé, Jackson Woodruff, Chris Cummins, and Michael FP O'Boyle. 2024. SLaDe: A Portable Small Language Model Decompiler for Optimized Assembly . In 2024 IEEE/ACM International Symposium on Code Generation and Optimization (CGO)

    work page 2024

  3. [3]

    Todd Austin. 2024. https://github.com/toddmaustin/bringup-bench bringup-bench

    work page 2024

  4. [4]

    Fabrice Bellard. 2005. https://www.qemu.org/ Qemu, a fast and portable dynamic translator . In USENIX Annual Technical Conference, FREENIX Track

    work page 2005

  5. [5]

    Emily Blem, Jaikrishnan Menon, and Karthikeyan Sankaralingam. 2013. Power struggles: Revisiting the risc vs. cisc debate on contemporary arm and x86 architectures. In 2013 IEEE 19th International Symposium on High Performance Computer Architecture (HPCA), pages 1--12. IEEE

    work page 2013

  6. [6]

    Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde De Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, and 1 others. 2021. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374

    arXiv 2021

  7. [7]

    CloudPanel . 2023. https://www.cloudpanel.io/blog/arm-based-servers/ What are arm-based servers? comparison with x86, benefits and drawbacks . Accessed: 2024-10-31

    work page 2023

  8. [8]

    Matthew Connatser. 2023. https://www.tomshardware.com/tech-industry/semiconductors/intels-ceo-says-moores-law-is-slowing-to-a-three-year-cadence-but-its-not-dead-yet Intel's ceo says moore's law is slowing to a three-year cadence, but it's not dead yet . Tom's Hardware

    work page 2023

Show all 60 references
  1. [9]

    Chris Cummins, Volker Seeker, Dejan Grubisic, Baptiste Roziere, Jonas Gehring, Gabriel Synnaeve, and Hugh Leather. 2024. Meta large language model compiler: Foundation models of compiler optimization. arXiv preprint arXiv:2407.02524

    2024 arXiv

  2. [10]

    Anderson Faustino Da Silva, Bruno Conde Kind, Jos \'e Wesley de Souza Magalh \ a es, Jer \^o nimo Nunes Rocha, Breno Campos Ferreira Guimaraes, and Fernando Magno Quin \ a o Pereira. 2021. Anghabench: A suite with one million compilable c benchmarks for code-size reduction. In...

    2021

  3. [11]

    Tri Dao. 2023. Flashattention-2: Faster attention with better parallelism and work partitioning. arXiv preprint arXiv:2307.08691

    2023 arXiv

  4. [12]

    Robert H Dennard, Fritz H Gaensslen, Hwa-Nien Yu, V Leo Rideout, Ernest Bassous, and Andre R LeBlanc. 1974. Design of ion-implanted mosfet's with very small physical dimensions. IEEE Journal of solid-state circuits, 9(5):256--268

    1974

  5. [14]

    Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, Linjun Shou, Bing Qin, Ting Liu, Daxin Jiang, and 1 others. 2020. Codebert: A pre-trained model for programming and natural languages. arXiv preprint arXiv:2002.08155

    2020 arXiv

  6. [15]

    Philip J Fleming and John J Wallace. 1986. How not to lie with statistics: the correct way to summarize benchmark results. Communications of the ACM

    1986

  7. [16]

    Github - ggerganov/llama.cpp: Llm inference in c/c++

    Ggerganov. Github - ggerganov/llama.cpp: Llm inference in c/c++. https://github.com/ggerganov/llama.cpp. Accessed: 2024-10-31

    2024

  8. [17]

    Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, and 1 others. 2025. Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning. arXiv preprint arXiv:2501.12948

    2025 arXiv

  9. [18]

    Daya Guo, Qihao Zhu, Dejian Yang, Zhenda Xie, Kai Dong, Wentao Zhang, Guanting Chen, Xiao Bi, Yu Wu, YK Li, and 1 others. 2024. Deepseek-coder: When the large language model meets programming--the rise of code intelligence. arXiv preprint arXiv:2401.14196

    2024 arXiv

  10. [19]

    Udit Gupta, Young Geun Kim, Sylvia Lee, Jordan Tse, Hsien-Hsin S Lee, Gu-Yeon Wei, David Brooks, and Carole-Jean Wu. 2021. Chasing carbon: The elusive environmental footprint of computing. In 2021 IEEE International Symposium on High-Performance Computer Architecture (HPCA), p...

    2021

  11. [20]

    Jingxuan He, Pesho Ivanov, Petar Tsankov, Veselin Raychev, and Martin Vechev. 2018. Debin: Predicting debug information in stripped binaries. In Proceedings of the 2018 ACM SIGSAC Conference on Computer and Communications Security, pages 1667--1680

    2018

  12. [21]

    Mark Horowitz. 2014. 1.1 computing's energy problem (and what we can do about it). In 2014 IEEE international solid-state circuits conference digest of technical papers (ISSCC), pages 10--14. IEEE

    2014

  13. [22]

    Pin-Lun Hsu, Yun Dai, Vignesh Kothapalli, Qingquan Song, Shao Tang, Siyu Zhu, Steven Shimizu, Shivam Sahni, Haowen Ning, and Yanning Chen. 2024. Liger kernel: Efficient triton kernels for llm training. arXiv preprint arXiv:2410.10989

    2024 arXiv

  14. [23]

    Peiwei Hu, Ruigang Liang, and Kai Chen. 2024. Degpt: Optimizing decompiler output with llm. In Proceedings 2024 Network and Distributed System Security Symposium (2024). https://api. semanticscholar. org/CorpusID, volume 267622140

    2024

  15. [25]

    Binyuan Hui, Jian Yang, Zeyu Cui, Jiaxi Yang, Dayiheng Liu, Lei Zhang, Tianyu Liu, Jiajun Zhang, Bowen Yu, Keming Lu, and 1 others. 2024 b . Qwen2. 5-coder technical report. arXiv preprint arXiv:2409.12186

    2024 arXiv

  16. [26]

    IONOS . 2024. Arm processor architecture explained. https://www.ionos.com/digitalguide/server/know-how/arm-processor-architecture/. Accessed: 2025-04-12

    2024

  17. [27]

    Norman P Jouppi, Cliff Young, Nishant Patil, David Patterson, Gaurav Agrawal, Raminder Bajwa, Sarah Bates, Suresh Bhatia, Nan Boden, Al Borchers, and 1 others. 2017. In-datacenter performance analysis of a tensor processing unit. In Proceedings of the 44th annual international...

    2017

  18. [28]

    Denis Kocetkov, Raymond Li, Loubna Ben Allal, Jia Li, Chenghao Mou, Carlos Mu \ n oz Ferrandis, Yacine Jernite, Margaret Mitchell, Sean Hughes, Thomas Wolf, and 1 others. 2022. The stack: 3 tb of permissively licensed source code. arXiv preprint arXiv:2211.15533

    2022 arXiv

  19. [29]

    Marie-Anne Lachaux, Baptiste Roziere, Lowik Chanussot, and Guillaume Lample. 2020. Unsupervised translation of programming languages. arXiv preprint arXiv:2006.03511

    2020 arXiv

  20. [30]

    Chris Lattner. 2008. Llvm and clang: Next generation compiler technology. In The BSD conference, volume 5, pages 1--20

    2008

  21. [31]

    Celine Lee, Abdulrahman Mahmoud, Michal Kurek, Simone Campanoni, David Brooks, Stephen Chong, Gu-Yeon Wei, and Alexander M Rush. 2024. Guess & sketch: Language model guided transpilation. In The Twelfth International Conference on Learning Representations

    2024

  22. [32]

    Aixin Liu, Bei Feng, Bin Wang, Bingxuan Wang, Bo Liu, Chenggang Zhao, Chengqi Dengr, Chong Ruan, Damai Dai, Daya Guo, and 1 others. 2024. Deepseek-v2: A strong, economical, and efficient mixture-of-experts language model. arXiv preprint arXiv:2405.04434

    2024 arXiv

  23. [33]

    Mingjie Liu, Yun-Da Tsai, Wenfei Zhou, and Haoxing Ren. 2025. https://openreview.net/forum?id=8KQzoD5XAr Craft RTL : High-quality synthetic data generation for verilog code models with correct-by-construction non-textual representations and targeted code repair . In The Thirte...

    2025

  24. [34]

    I Loshchilov. 2017. Decoupled weight decay regularization. arXiv preprint arXiv:1711.05101

    2017 arXiv

  25. [35]

    Anton Lozhkov, Raymond Li, Loubna Ben Allal, Federico Cassano, Joel Lamy-Poirier, Nouamane Tazi, Ao Tang, Dmytro Pykhtar, Jiawei Liu, Yuxiang Wei, and 1 others. 2024. Starcoder 2 and the stack v2: The next generation. arXiv preprint arXiv:2402.19173

    2024 arXiv

  26. [36]

    Alfonso Maruccia. 2025. https://www.techspot.com/news/107395-arm-expects-win-half-data-center-cpu-market.html Arm is aiming to win half of data center cpu market by year's end . Accessed: 2025-05-20

    2025

  27. [37]

    Gonzalez, Elizabeth Polgreen, and Sanjit A

    Federico Mora, Justin Wong, Haley Lepe, Sahil Bhatia, Karim Elmaaroufi, George Varghese, Joseph E. Gonzalez, Elizabeth Polgreen, and Sanjit A. Seshia. 2024. https://openreview.net/forum?id=kQPzFiwVIu Synthetic programming elicitation for text-to-code in very low-resource progr...

    2024

  28. [38]

    Timothy Prickett Morgan. 2022. https://www.nextplatform.com/2022/01/04/inside-amazons-graviton3-arm-server-processor/ Inside amazon’s graviton3 arm server processor . The Next Platform

    2022

  29. [39]

    Glenford J Myers, Corey Sandler, and Tom Badgett. 2011. The art of software testing. John Wiley & Sons

    2011

  30. [40]

    NVIDIA Corporation . 2024. NVIDIA Grace CPU and Arm Architecture . https://www.nvidia.com/en-us/data-center/grace-cpu/. Accessed: 2025-04-12

    2024

  31. [41]

    OpenAI. 2024. Hello gpt4-o. https://openai.com/index/hello-gpt-4o/. Accessed: 2024-10-31

    2024

  32. [42]

    David Patterson, Joseph Gonzalez, Quoc Le, Chen Liang, Lluis-Miquel Munguia, Daniel Rothchild, David So, Maud Texier, and Jeff Dean. 2021. Carbon emissions and large neural network training. arXiv preprint arXiv:2104.10350

    2021 arXiv

  33. [43]

    GNU Project. 2025. riscv64-linux-gnu-gcc: The gnu compiler collection for risc-v (64-bit). https://gcc.gnu.org/. Accessed: 2025-04-12

    2025

  34. [44]

    Radcolor. n.d. Radcolor/ARM-linux-gnueabi: Bleeding edge GNU gcc toolchains (cc only) built from sources with latest binutils and glibc (for arm) . https://github.com/radcolor/arm-linux-gnueabi. GitHub

  35. [45]

    Jeff Rasley, Samyam Rajbhandari, Olatunji Ruwase, and Yuxiong He. 2020. Deepspeed: System optimizations enable training deep learning models with over 100 billion parameters. In Proceedings of the 26th ACM SIGKDD international conference on knowledge discovery & data mining, p...

    2020

  36. [46]

    Red Hat . 2022. https://www.redhat.com/en/topics/linux/ARM-vs-x86 Arm vs x86: What's the difference? Accessed: 2025-05-19

    2022

  37. [47]

    Reuters. 2025. Arm expects its share of data center cpu market to surge as sales rocket 50\ https://www.reuters.com/technology/arm-expects-its-share-data-center-cpu-market-sales-rocket-50-this-year-2025-03-31/. Accessed: 2025-04-12

    2025

  38. [48]

    Baptiste Roziere, Jonas Gehring, Fabian Gloeckle, Sten Sootla, Itai Gat, Xiaoqing Ellen Tan, Yossi Adi, Jingyu Liu, Romain Sauvestre, Tal Remez, and 1 others. 2023. Code llama: Open foundation models for code. arXiv preprint arXiv:2308.12950

    2023 arXiv

  39. [49]

    Phillip Rust, Jonas Pfeiffer, Ivan Vuli \'c , Sebastian Ruder, and Iryna Gurevych. 2020. How good is your tokenizer? on the monolingual performance of multilingual language models. arXiv preprint arXiv:2012.15613

    2020 arXiv

  40. [50]

    Richard L Sites, Anton Chernoff, Matthew B Kirk, Maurice P Marks, and Scott G Robinson. 1993. Binary translation. Communications of the ACM, 36(2):69--81

    1993

  41. [51]

    Jianlin Su, Murtadha Ahmed, Yu Lu, Shengfeng Pan, Wen Bo, and Yunfeng Liu. 2024. Roformer: Enhanced transformer with rotary position embedding. Neurocomputing, 568:127063

    2024

  42. [52]

    Hanzhuo Tan, Qi Luo, Jing Li, and Yuqun Zhang. 2024. Llm4decompile: Decompiling binary code with large language models. arXiv

    2024

  43. [53]

    Sourabh Kumar Verma. 2024. Exploring windows on arm: The future of computing. https://techcommunity.microsoft.com/blog/educatordeveloperblog/exploring-windows-on-arm-the-future-of-computing/4260186. Microsoft Tech Community Blog

    2024

  44. [54]

    Hao Wang, Wenjie Qu, Gilad Katz, Wenyu Zhu, Zeyu Gao, Han Qiu, Jianwei Zhuge, and Chao Zhang. 2022. Jtrans: Jump-aware transformer for binary code similarity detection. In Proceedings of the 31st ACM SIGSOFT International Symposium on Software Testing and Analysis

    2022

  45. [55]

    Yue Wang, Weishi Wang, Shafiq Joty, and Steven CH Hoi. 2021. Codet5: Identifier-aware unified pre-trained encoder-decoder models for code understanding and generation. arXiv preprint arXiv:2109.00859

    2021 arXiv

  46. [56]

    Zhe Wang, John Smith, and Jane Doe. 2024. https://doi.org/10.1145/3650212.3652144 Evaluating the effectiveness of decompilers . In Proceedings of the 2024 ACM Conference on Software Analysis, New York, NY, USA. ACM

    2024

  47. [57]

    Xiangzhe Xu, Shiwei Feng, Yapeng Ye, Guangyu Shen, Zian Su, Siyuan Cheng, Guanhong Tao, Qingkai Shi, Zhuo Zhang, and Xiangyu Zhang. 2023. Improving binary code similarity transformer models by semantics-driven instruction deemphasis. In Proceedings of the 32nd ACM SIGSOFT Inte...

    2023

  48. [58]

    Zeping Yu, Rui Cao, Qiyi Tang, Sen Nie, Junzhou Huang, and Shi Wu. 2020. Order matters: Semantic-aware neural networks for binary code similarity detection. In Proceedings of the AAAI conference on artificial intelligence

    2020

  49. [59]

    Siyuan Zheng, Zhi Yang, Cedric Renggli, Yuxiang Pu, Zixuan Li, Mohammad Shoeybi, Lin Zhang, Dheevatsa Narayanan, Haotian Zhao, Zhewei Yao, and Tianqi Chen. 2023. vllm: A high-throughput and memory-efficient inference engine for llms. https://github.com/vllm-project/vllm. GitHu...

    2023

  50. [60]

    Yaowei Zheng, Richong Zhang, Junhao Zhang, Yanhan Ye, Zheyan Luo, Zhangchi Feng, and Yongqiang Ma. 2024. Llamafactory: Unified efficient fine-tuning of 100+ language models. arXiv preprint arXiv:2403.13372

    2024 arXiv

  51. [61]

    online" 'onlinestring :=

    ENTRY address archivePrefix author booktitle chapter edition editor eid eprint eprinttype howpublished institution journal key month note number organization pages publisher school series title type volume year doi pubmed url lastchecked label extra.label sort.label short.list...

  52. [62]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 gl...

Pith tools

Reviewed August 15, 2026 · model on record in the stance chip above.