LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]libcperciva/tests/mpool/main.c
// Function: main
int
main(int argc, char * argv[])
{
	unsigned long sets, reps;
	unsigned int use_mpool;
	long long delta_us;

	WARNP_INIT;

	/* Parse args. */
	if ((argc != 4) || (PARSENUM(&sets, argv[1])) ||
	    (PARSENUM(&reps, argv[2])) || (PARSENUM(&use_mpool, argv[3]))) {
		printf("usage: test_mpool SETS REPS TYPE\n");
		goto err0;
	}

	/* Sanity check. */
	if (!((sets > 0) && (reps > 0))) {
		fprintf(stderr, "SETS and REPS must be greater than zero\n");
		goto err0;
	}

	/* Time memory allocation method, and output it. */
	if ((delta_us = time_func(sets, reps, use_mpool)) < 0)
		goto err0;
	printf("%lld\n", delta_us);

	/* Success! */
	exit(0);

err0:
	/* Failure! */
	exit(1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movl %edi, %ebx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x17ec
callq 0x1be8
cmpl $0x4, %ebx
jne 0x191f
callq 0x1060
movl $0x0, (%rax)
movq 0x8(%r15), %r12
testq %r12, %r12
je 0x18f9
movq %rax, %rbx
movq %rsp, %r13
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x1140
movq %rax, %r14
movq (%r13), %rax
cmpq %r12, %rax
je 0x18f1
cmpb $0x0, (%rax)
jne 0x18f1
cmpl $0x0, (%rbx)
jne 0x191f
movq 0x10(%r15), %r13
testq %r13, %r13
je 0x18f9
movq %rsp, %rbp
movq %r13, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x1140
movq %rax, %r12
movq (%rbp), %rax
cmpq %r13, %rax
je 0x18f1
cmpb $0x0, (%rax)
jne 0x18f1
cmpl $0x0, (%rbx)
jne 0x191f
movq 0x18(%r15), %r15
testq %r15, %r15
je 0x18f9
movq %rsp, %r13
movq %r15, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x1140
movq (%r13), %rdx
movl $0x16, %ecx
cmpq %r15, %rdx
je 0x191d
cmpb $0x0, (%rdx)
jne 0x191d
movq %rax, %rcx
shrq $0x20, %rcx
jne 0x1918
cmpl $0x0, (%rbx)
jne 0x191f
testq %r14, %r14
setne %cl
testq %r12, %r12
setne %dl
testb %dl, %cl
jne 0x192d
movq 0x272a(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0x7db(%rip), %rdi       # 0x20b3
movl $0x28, %esi
movl $0x1, %edx
callq 0x1180
movl $0x1, %edi
callq 0x1170
movl $0x16, (%rbx)
jmp 0x191f
leaq 0x834(%rip), %rdi       # 0x2134
leaq 0x837(%rip), %rsi       # 0x213e
leaq 0x846(%rip), %rcx       # 0x2154
movl $0xbb, %edx
callq 0x10b0
movl $0x22, %ecx
movl %ecx, (%rbx)
leaq 0x883(%rip), %rdi       # 0x21a9
callq 0x1070
jmp 0x18e7
movq %r14, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x13d5
testq %rax, %rax
js 0x18e7
leaq 0x796(%rip), %rdi       # 0x20dc
movq %rax, %rsi
xorl %eax, %eax
callq 0x10a0
xorl %edi, %edi
callq 0x1170
// File: /workspace/github_c_makefile_star2_O3/wuxb45[P]SLB/ibkvcli.c
// Function: test_ibkv
int
test_ibkv(const int argc, char ** const argv)
{
  if (argc < 6 || (strcmp(argv[0], "api") != 0)) {
    return -1;
  }

  const u64 pid = strtoull(argv[1], NULL, 10);
  char * const host = argv[2];
  const int pn = atoi(argv[3]);
  const u64 depth = strtoull(argv[4], NULL, 10);
  const u64 batch = strtoull(argv[5], NULL, 10);

  char *pref[64] = {};
  for (int i = 0; i < 6; i++) {
    pref[i] = argv[i];
  }
  pref[6] = NULL;

  struct worker_info wi;
  wi.port = ib_port_create(pid);
  wi.host = host;
  wi.pn = pn;
  wi.depth = depth;
  wi.batch = batch;

  struct pass_info pi = {};
  pi.api = &wi;
  pi.vctr_size = 4;
  pi.wf = ibkv_worker;
  pi.af = ibkv_analyze;
  const int n2 = maptest_passes(argc - 6, argv + 6, pref, &pi);
  ib_port_destroy(wi.port);
  if (n2 < 0) {
    return n2;
  }
  return 6 + n2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl $0x6, %edi
jl 0x70b5
movq %rsi, %rbx
movl %edi, %r14d
movq (%rsi), %rdi
leaq 0xe071(%rip), %rsi      # 0x15010
callq 0x64b0
testl %eax, %eax
jne 0x70b5
movq 0x8(%rbx), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x6580
movq %rax, -0x38(%rbp)
movq 0x10(%rbx), %rax
movq %rax, -0x40(%rbp)
movq 0x18(%rbx), %rdi
callq 0x63e0
movl %eax, -0x2c(%rbp)
movq 0x20(%rbx), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x6580
movq %rax, %r13
movq 0x28(%rbx), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x6580
movq %rax, %r15
leaq -0x260(%rbp), %r12
movl $0x1d0, %edx            # imm = 0x1D0
movq %r12, %rdi
xorl %esi, %esi
callq 0x6080
vmovups (%rbx), %ymm0
vmovups 0x10(%rbx), %ymm1
vmovups %ymm0, -0x30(%r12)
vmovups %ymm1, -0x20(%r12)
movq -0x38(%rbp), %rdi
vzeroupper
callq 0x13fdc
leaq -0x90(%rbp), %r12
movq %rax, (%r12)
movq -0x40(%rbp), %rax
movq %rax, 0x8(%r12)
movl -0x2c(%rbp), %eax
movl %eax, 0x10(%r12)
movq %r13, 0x18(%r12)
movq %r15, 0x20(%r12)
leaq -0x68(%rbp), %rcx
movq $0x0, (%rcx)
movq %r12, 0x8(%rcx)
movq $0x4, 0x10(%rcx)
leaq 0x53(%rip), %rax        # 0x70ca
movq %rax, 0x18(%rcx)
leaq 0x484(%rip), %rax       # 0x7506
movq %rax, 0x20(%rcx)
addl $-0x6, %r14d
addq $0x30, %rbx
leaq -0x290(%rbp), %rdx
movl %r14d, %edi
movq %rbx, %rsi
callq 0x133f4
movl %eax, %ebx
movq (%r12), %rdi
callq 0x14128
leal 0x6(%rbx), %r15d
testl %ebx, %ebx
cmovsl %ebx, %r15d
movl %r15d, %eax
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wuxb45[P]SLB/ibkvcli.c
// Function: ibkv_analyze
static bool
ibkv_analyze(struct vctr * const va, const double dt, struct damp * const damp, char * const out)
{
  u64 v[8];
  for (u64 i = 0; i < 4; i++) {
    v[i] = vctr_get(va, i);
  }

  const u64 nrop = v[XSA] + v[XDA] + v[XGA] + v[XPA];
  const double mops = ((double)nrop) / (dt * 1.0e6);
  const bool done = damp_add_test(damp, mops);
  const double havg = damp_average(damp);
  const char * const pat = " set %"PRIu64" del %"PRIu64" get %"PRIu64" pro %"PRIu64" mops %.2lf havg %.2lf\n";
  sprintf(out, pat, v[XSA], v[XDA], v[XGA], v[XPA], mops, havg);
  return done;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, -0x40(%rbp)
movq %rsi, %r14
vmovsd %xmm0, -0x30(%rbp)
movq %rdi, %r15
xorl %r12d, %r12d
movq %r15, %rdi
movq %r12, %rsi
callq 0x9e53
movq %rax, -0x80(%rbp,%r12,8)
incq %r12
cmpq $0x4, %r12
jne 0x7529
movq -0x80(%rbp), %r15
movq -0x78(%rbp), %r12
movq -0x70(%rbp), %r13
movq -0x68(%rbp), %rbx
leaq (%r13,%rbx), %rcx
addq %r12, %rcx
addq %r15, %rcx
vcvtusi2sd %rcx, %xmm1, %xmm0
vmovsd -0x30(%rbp), %xmm1
vmulsd 0xda98(%rip), %xmm1, %xmm1 # 0x15008
vdivsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, -0x38(%rbp)
movq %r14, %rdi
callq 0x9c7b
movb %al, -0x30(%rbp)
movq %r14, %rdi
callq 0x9b8f
vmovapd %xmm0, %xmm1
leaq 0xda7d(%rip), %rsi      # 0x15014
movq -0x40(%rbp), %rdi
movq %r15, %rdx
movq %r12, %rcx
movq %r13, %r8
movq %rbx, %r9
vmovsd -0x38(%rbp), %xmm0
movb $0x2, %al
callq 0x6300
movb -0x30(%rbp), %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/evm.c
// Function: disassemble
static void disassemble(const char *contents) {
    disassembleInit();
    while (disassembleValid(&contents)) {
        disassembleNextOp(&contents);
    }
    disassembleFinalize();
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq %rdi, (%rbx)
xorl %eax, %eax
callq 0x10ec0
movq %rbx, %rdi
callq 0x116e2
testl %eax, %eax
je 0x47a6
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x10f74
movq %rbx, %rdi
callq 0x116e2
testl %eax, %eax
jne 0x4792
xorl %eax, %eax
callq 0x116f3
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/dio.c
// Function: jsonScanChar
static void jsonScanChar(const char **iter, char expected) {
    for (char ch; (ch = **iter) != expected; (*iter)++) {
        if (jsonIgnores(ch)) {
            if (ch == '\n') {
                lineNumber++;
            }
        } else {
            fprintf(stderr, "Config: when seeking '%c' found unexpected character '%c' on line %" PRIu64 "\n", expected, ch, lineNumber);
            _exit(1);
        }
    }
    (*iter)++;
}

// Assembly:
pushq %rax
movq (%rdi), %rcx
movb (%rcx), %r9b
cmpb %sil, %r9b
je 0x7051
movq 0x19a5e(%rip), %rdx     # 0x20a48
incq %rcx
movabsq $0xa00000001000401, %r8 # imm = 0xA00000001000401
movzbl %r9b, %eax
leal -0x22(%rax), %r10d
cmpl $0x3b, %r10d
ja 0x700b
btq %r10, %r8
jb 0x7059
cmpl $0x7b, %eax
je 0x7059
cmpl $0x7d, %eax
je 0x7059
leal -0x30(%r9), %r10d
cmpb $0xa, %r10b
jb 0x7059
movl %r9d, %r10d
andb $-0x21, %r10b
addb $-0x41, %r10b
cmpb $0x1a, %r10b
jb 0x7059
cmpb $0xa, %r9b
jne 0x7040
incq %rdx
movq %rdx, 0x19a08(%rip)     # 0x20a48
movq %rcx, (%rdi)
movb (%rcx), %r9b
incq %rcx
cmpb %sil, %r9b
jne 0x6ff7
decq %rcx
incq %rcx
movq %rcx, (%rdi)
popq %rax
retq
movzbl %sil, %esi
movl %eax, %edi
callq 0x3583
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/dio.c
// Function: jsonScanStr
static const char *jsonScanStr(const char **iter) {
    jsonScanChar(iter, '"');
    const char *start = *iter;
    for (char ch; (ch = **iter) != '"' && ch; (*iter)++);
    jsonSkipExpectedChar(iter, '"');
    return start;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x22, %esi
callq 0x6fd7
movq (%rbx), %r14
leaq 0x1(%r14), %rax
movzbl -0x1(%rax), %ecx
cmpl $0x22, %ecx
je 0x73f0
testl %ecx, %ecx
je 0x73f0
movq %rax, (%rbx)
incq %rax
jmp 0x73db
movq %rbx, %rdi
movl $0x22, %esi
callq 0x70d3
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/dio.c
// Function: jsonReadAddressString
static address_t *jsonReadAddressString(const char **iter) {
    jsonSkipExpectedChar(iter, '"');
    address_t *address = jsonReadAddress(iter);
    jsonSkipExpectedChar(iter, '"');
    return address;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x22, %esi
callq 0x70d3
movq %rbx, %rdi
callq 0x743c
movq %rax, %r14
movq %rbx, %rdi
movl $0x22, %esi
callq 0x70d3
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/dio.c
// Function: jsonReadAddress
static address_t *jsonReadAddress(const char **iter) {
    jsonSkipExpectedChar(iter, '0');
    jsonSkipExpectedChar(iter, 'x');
    address_t *address = malloc(sizeof(address_t));
    for (unsigned int i = 0; i < 20; i++) {
        address->address[i] = hexString16ToUint8(*iter);
        *iter += 2;
    }
    return address;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x30, %esi
callq 0x70d3
movq %rbx, %rdi
movl $0x78, %esi
callq 0x70d3
movl $0x14, %edi
callq 0x3200
movq %rax, %r14
movq (%rbx), %rbp
movq 0x10b80(%rip), %rdx     # 0x17ff8
leaq 0xad2c(%rip), %r15      # 0x121ab
xorl %r13d, %r13d
movzbl (%rbp), %ecx
leal -0x30(%rcx), %r12d
cmpb $0xa, %r12b
jb 0x74a9
leal -0x61(%rcx), %eax
cmpb $0x5, %al
ja 0x749c
addb $-0x57, %cl
jmp 0x74a6
leal -0x41(%rcx), %eax
cmpb $0x5, %al
ja 0x74ec
addb $-0x37, %cl
movl %ecx, %r12d
movzbl 0x1(%rbp), %ecx
leal -0x30(%rcx), %eax
cmpb $0xa, %al
jb 0x74cc
leal -0x61(%rcx), %eax
cmpb $0x5, %al
ja 0x74c0
addb $-0x57, %cl
jmp 0x74ca
leal -0x41(%rcx), %eax
cmpb $0x5, %al
ja 0x7506
addb $-0x37, %cl
movl %ecx, %eax
shlb $0x4, %r12b
addb %al, %r12b
movb %r12b, (%r14,%r13)
movq (%rbx), %rbp
addq $0x2, %rbp
movq %rbp, (%rbx)
incq %r13
cmpq $0x14, %r13
jne 0x7482
jmp 0x751f
movq (%rdx), %rdi
movq %r15, %rsi
movq %rdx, %r12
movl %ecx, %edx
xorl %eax, %eax
callq 0x31d0
movq %r12, %rdx
movb $-0x1, %r12b
jmp 0x74a9
movq (%rdx), %rdi
movq %r15, %rsi
movq %rdx, %rbp
movl %ecx, %edx
xorl %eax, %eax
callq 0x31d0
movq %rbp, %rdx
movb $-0x1, %al
jmp 0x74cc
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/dio.c
// Function: verifyConstructResult
static void verifyConstructResult(result_t *constructResult, entry_t *entry) {
    if (entry->code.size) {
        // verify result code matches entry->code if present
        if (constructResult->returnData.size != entry->code.size || memcmp(constructResult->returnData.content, entry->code.content, entry->code.size)) {
            fputs("Code mismatch at address ", stderr);
            fprintAddress(stderr, (*entry->address));
            fprintf(stderr, ":\n`%s -c %s`:\n", derivedPath, entry->constructPath);
            fprintData(stderr, constructResult->returnData);
            fprintf(stderr, "\nexpected:\n");
            fprintData(stderr, entry->code);
            fputc('\n', stderr);
            _exit(-1);
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x38(%rsi), %rdx
testq %rdx, %rdx
je 0x755a
movq %rsi, %r14
movq %rdi, %rbx
cmpq %rdx, (%rdi)
jne 0x7562
movq 0x8(%rbx), %rdi
movq 0x40(%r14), %rsi
callq 0x3210
testl %eax, %eax
jne 0x7562
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x38(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3617
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/evm.c
// Function: fprintLog
uint16_t fprintLog(FILE *file, const logChanges_t *log, int showLogIndex) {
    if (log == NULL) {
        return 0;
    }
    uint16_t items = fprintLog(file, log->prev, showLogIndex);
    if (items) {
        fputc(',', file);
    }
    if (showLogIndex) {
        fprintf(file, "{\"logIndex\":\"0x%x\",\"data\":\"0x", log->logIndex);
    } else {
        fprintf(file, "{\"data\":\"0x");
    }
    for (size_t i = 0; i < log->data.size; i++) {
        fprintf(file, "%02x", log->data.content[i]);
    }
    fputs("\",\"topics\":[", file);
    for (uint8_t i = log->topicCount; i-->0;) {
        fprintf(file, "\"0x%016" PRIx64 "%016" PRIx64 "%016" PRIx64 "%016" PRIx64 "\"",
            UPPER(UPPER(log->topics[i])),
            LOWER(UPPER(log->topics[i])),
            UPPER(LOWER(log->topics[i])),
            LOWER(LOWER(log->topics[i]))
        );
        if (i) {
            fputc(',', file);
        }
    }
    fputs("]}", file);
    return items + 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x7a45
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rsi), %rsi
callq 0x79f4
movl %eax, %ebx
testw %ax, %ax
je 0x7a29
movl $0x2c, %edi
movq %r14, %rsi
callq 0x3180
testl %ebp, %ebp
je 0x7a4c
movzwl 0xa(%r15), %edx
leaq 0xaf03(%rip), %rsi      # 0x1293c
movq %r14, %rdi
xorl %eax, %eax
callq 0x31d0
jmp 0x7a65
xorl %ebx, %ebx
jmp 0x7b3e
leaq 0xaf07(%rip), %rdi      # 0x1295a
movl $0xb, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x3290
cmpq $0x0, 0x10(%r15)
je 0x7a95
leaq 0xa90b(%rip), %r12      # 0x1237e
xorl %r13d, %r13d
movq 0x18(%r15), %rax
movzbl (%rax,%r13), %edx
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x31d0
incq %r13
cmpq 0x10(%r15), %r13
jb 0x7a76
leaq 0xaeca(%rip), %rdi      # 0x12966
movq %r14, %rsi
callq 0x3130
movzbl 0x8(%r15), %r13d
testq %r13, %r13
je 0x7b2d
leaq -0x1(%r13), %rbp
movq (%r15), %rax
movq %rbp, %rsi
shlq $0x5, %rsi
movq (%rax,%rsi), %rdx
movq 0x8(%rax,%rsi), %rcx
movq 0x10(%rax,%rsi), %r8
movq 0x18(%rax,%rsi), %r9
leaq 0xae9d(%rip), %rsi      # 0x12973
movq %r14, %rdi
xorl %eax, %eax
callq 0x31d0
testq %rbp, %rbp
je 0x7b2d
shll $0x5, %r13d
addq $-0x28, %r13
leaq 0xae7f(%rip), %r12      # 0x12973
movl $0x2c, %edi
movq %r14, %rsi
callq 0x3180
movq (%r15), %rax
movq -0x18(%rax,%r13), %rdx
movq -0x10(%rax,%r13), %rcx
movq -0x8(%rax,%r13), %r8
movq (%rax,%r13), %r9
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x31d0
addq $-0x20, %r13
decq %rbp
jne 0x7af4
leaq 0xae5c(%rip), %rdi      # 0x12990
movq %r14, %rsi
callq 0x3130
incl %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/evm.c
// Function: fprintLogs
uint16_t fprintLogs(FILE *file, const stateChanges_t *account, int showLogIndex) {
    fputs("{", file);
    uint16_t items = _fprintLogs(file, account, showLogIndex);
    fputs("}", file);
    return items;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xab6c(%rip), %rdi      # 0x129ba
movq %r15, %rsi
callq 0x3130
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x7e7c
movl %eax, %ebx
leaq 0xa33d(%rip), %rdi      # 0x121a9
movq %r15, %rsi
callq 0x3130
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/evm.c
// Function: fprintLogs
static uint16_t _fprintLogs(FILE *file, const stateChanges_t *account, int showLogIndex) {
    if (account == NULL) {
        return 0;
    }
    uint16_t items = _fprintLogs(file, account->next, showLogIndex);
    if (account->logChanges == NULL) {
        return items;
    }
    if (items) {
        fputc(',', file);
    }
    fputs("\"", file);
    fprintAddress(file, account->account);
    fputs("\":[", file);
    items += fprintLog(file, account->logChanges, showLogIndex);
    fputc(']', file);
    return items;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
testq %rsi, %rsi
je 0x7fff
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq 0x28(%rsi), %rsi
callq 0x7e7c
movl %eax, %ebx
cmpq $0x0, 0x18(%r15)
je 0x8001
movl %ebp, 0xc(%rsp)
testw %bx, %bx
je 0x7ec7
movl $0x2c, %edi
movq %r14, %rsi
callq 0x3180
leaq 0xa2c8(%rip), %rdi      # 0x12196
movq %r14, %rsi
callq 0x3130
movzbl (%r15), %edx
movzbl 0x1(%r15), %ecx
movzbl 0x2(%r15), %r8d
movzbl 0x3(%r15), %r9d
movzbl 0x4(%r15), %eax
movq %rax, 0x60(%rsp)
movzbl 0x5(%r15), %eax
movq %rax, 0x58(%rsp)
movzbl 0x6(%r15), %eax
movq %rax, 0x50(%rsp)
movzbl 0x7(%r15), %eax
movq %rax, 0x48(%rsp)
movzbl 0x8(%r15), %eax
movq %rax, 0x40(%rsp)
movzbl 0x9(%r15), %eax
movq %rax, 0x38(%rsp)
movzbl 0xa(%r15), %eax
movq %rax, 0x30(%rsp)
movzbl 0xb(%r15), %eax
movq %rax, 0x28(%rsp)
movzbl 0xc(%r15), %eax
movq %rax, 0x20(%rsp)
movzbl 0xd(%r15), %eax
movq %rax, 0x18(%rsp)
movzbl 0xe(%r15), %eax
movq %rax, 0x10(%rsp)
movzbl 0xf(%r15), %r13d
movzbl 0x10(%r15), %r10d
movzbl 0x11(%r15), %r11d
movzbl 0x12(%r15), %r12d
movzbl 0x13(%r15), %ebp
leaq 0xa3b9(%rip), %rsi      # 0x12330
movq %r14, %rdi
xorl %eax, %eax
pushq %rbp
pushq %r12
pushq %r11
pushq %r10
pushq %r13
pushq 0x38(%rsp)
pushq 0x48(%rsp)
pushq 0x58(%rsp)
pushq 0x68(%rsp)
pushq 0x78(%rsp)
pushq 0x88(%rsp)
pushq 0x98(%rsp)
pushq 0xa8(%rsp)
pushq 0xb8(%rsp)
pushq 0xc8(%rsp)
pushq 0xd8(%rsp)
callq 0x31d0
addq $0x80, %rsp
leaq 0xa999(%rip), %rdi      # 0x1296f
movq %r14, %rsi
callq 0x3130
movq 0x18(%r15), %rsi
movq %r14, %rdi
movl 0xc(%rsp), %edx
callq 0x79f4
addl %eax, %ebx
movl $0x5d, %edi
movq %r14, %rsi
callq 0x3180
jmp 0x8001
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/evm.c
// Function: getCurrentAccountStateChanges
stateChanges_t *getCurrentAccountStateChanges(result_t *result, context_t *context) {
    stateChanges_t **stateChanges = &result->stateChanges;
    while (*stateChanges != NULL) {
        if (AddressEqual(&(*stateChanges)->account, &context->account->address)) {
            return *stateChanges;
        }
        stateChanges = &(*stateChanges)->next;
    }
    // DNF
    *stateChanges = calloc(1, sizeof(stateChanges_t));
    AddressCopy(&(*stateChanges)->account, &context->account->address);
    return *stateChanges;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x38(%rdi), %rdx
testq %rdx, %rdx
je 0x8062
movq 0x8008(%rbx), %rax
movb (%rax), %cl
movq %rdx, %r14
cmpb %cl, (%rdx)
jne 0x8053
xorl %esi, %esi
movq %rsi, %rdx
cmpq $0x13, %rsi
je 0x804d
movb 0x1(%r14,%rdx), %dil
leaq 0x1(%rdx), %rsi
cmpb 0x1(%rax,%rdx), %dil
je 0x8034
cmpq $0x12, %rdx
ja 0x8090
movq 0x28(%r14), %rdx
testq %rdx, %rdx
jne 0x802b
addq $0x28, %r14
jmp 0x8069
movq %rdi, %r14
addq $0x38, %r14
movl $0x1, %edi
movl $0x30, %esi
callq 0x31b0
movq %rax, (%r14)
movq 0x8008(%rbx), %rcx
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
jmp 0x8093
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/evm.c
// Function: getAccount
static account_t *getAccount(const address_t address) {
    if (AddressIsPrecompile(address)) {
        if (PrecompileIsKnownPrecompile(address)) {
            account_t *precompile = knownPrecompiles + address.address[19];
            AddressCopy(precompile->address, address);
            precompile->warm = evmIteration;
            return precompile;
        } else {
            fputs("Unknown precompile ", stderr);
            fprintAddress(stderr, address);
            fputc('\n', stderr);
        }
    }
    account_t *result = accounts;
    while (result < emptyAccount && !AddressEqual(&result->address, &address)) result++;
    if (result == emptyAccount) {
        emptyAccount++;
        AddressCopy(result->address, address);
        result->code.size = 0;
        result->nonce = 0;
        result->balance[0] = 0;
        result->balance[1] = 0;
        result->balance[2] = 0;
    }
    return result;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x20(%rsp), %rbx
movdqa (%rbx), %xmm1
pxor %xmm0, %xmm0
pcmpeqb %xmm1, %xmm0
pmovmskb %xmm0, %eax
xorl $0xffff, %eax           # imm = 0xFFFF
jne 0x835c
cmpb $0x0, 0x30(%rsp)
jne 0x835c
cmpb $0x0, 0x31(%rsp)
jne 0x835c
movzbl 0x13(%rbx), %esi
cmpq $0xa, %rsi
ja 0x834a
leaq (%rsi,%rsi,4), %rcx
shll $0x4, %ecx
leaq 0x205078b(%rip), %rdx   # 0x2058ab0
leaq (%rdx,%rcx), %rax
movl 0x10(%rbx), %esi
movl %esi, 0x10(%rcx,%rdx)
movdqu (%rbx), %xmm0
movdqu %xmm0, (%rcx,%rdx)
movq 0x2050740(%rip), %rsi   # 0x2058a80
movq %rsi, 0x38(%rcx,%rdx)
jmp 0x83e3
movq %rbx, %rdi
movdqa %xmm1, (%rsp)
callq 0x3b3e
movdqa (%rsp), %xmm1
movq 0x203c70d(%rip), %rcx   # 0x2044a70
leaq 0x203c716(%rip), %rax   # 0x2044a80
cmpq %rax, %rcx
jbe 0x83ad
movd %xmm1, %edx
leaq 0x203c706(%rip), %rax   # 0x2044a80
cmpb %dl, (%rax)
jne 0x83a4
movq $-0x1, %rsi
cmpq $0x12, %rsi
je 0x83ad
movb 0x2(%rax,%rsi), %r8b
leaq 0x1(%rsi), %rdi
cmpb 0x2(%rbx,%rsi), %r8b
movq %rdi, %rsi
je 0x8385
cmpq $0x12, %rdi
ja 0x83ad
addq $0x50, %rax
cmpq %rcx, %rax
jb 0x837a
cmpq %rcx, %rax
jne 0x83e3
addq $0x50, %rcx
movq %rcx, 0x203c6b3(%rip)   # 0x2044a70
movl 0x10(%rbx), %ecx
movl %ecx, 0x10(%rax)
movdqu (%rbx), %xmm0
movdqu %xmm0, (%rax)
movq $0x0, 0x30(%rax)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x14(%rax)
movl $0x0, 0x24(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/evm.c
// Function: getAccountStorage
static storage_t *getAccountStorage(account_t *account, const uint256_t *key) {
    storage_t **storage = &account->storage;
    while (*storage != NULL) {
        if (equal256(&(*storage)->key, key)) {
            return *storage;
        }
        storage = &(*storage)->next;
    }
    *storage = calloc(1, sizeof(storage_t));
    copy256(&(*storage)->key, key);
    return *storage;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
addq $0x40, %rbx
testq %rdi, %rdi
je 0x84eb
movq %r14, %rsi
callq 0xce67
testb %al, %al
jne 0x8508
movq (%rbx), %rbx
movq 0x68(%rbx), %rdi
addq $0x68, %rbx
jmp 0x84cd
movl $0x1, %edi
movl $0x70, %esi
callq 0x31b0
movq %rax, (%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0xc649
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/evm.c
// Function: txCreate
result_t txCreate(address_t from, uint64_t gas, val_t value, data_t input) {
    account_t *fromAccount = getAccount(from);
    fromAccount->warm = evmIteration;
    account_t *coinbaseAccount = getAccount(coinbase);
    coinbaseAccount->warm = evmIteration;
    result_t result = evmCreate(fromAccount, gas, value, input);
    evmIteration++;
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movl 0x60(%rsp), %eax
movl %eax, 0x10(%rsp)
movaps 0x50(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x82de
movq %rax, %rbp
movq 0x204fd20(%rip), %rax   # 0x2058a80
movq %rax, 0x38(%rbp)
movl 0x204fd3e(%rip), %eax   # 0x2058aa8
movl %eax, 0x10(%rsp)
movups 0x204fd23(%rip), %xmm0  # 0x2058a98
movups %xmm0, (%rsp)
callq 0x82de
movq 0x204fcfb(%rip), %rcx   # 0x2058a80
movq %rcx, 0x38(%rax)
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %rbx, %r9
callq 0x8b65
incq 0x204fcd9(%rip)         # 0x2058a80
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/evm.c
// Function: evmCall
static result_t _evmCall(context_t *callContext) {
    callContext->top = callContext->bottom;
    callContext->returnData.size = 0;

    memory_init(&callContext->memory, 0);

    uint64_t startGas = callContext->gas;

    callstack.next += 1;
    result_t result = doCall(callContext);
    callstack.next -= 1;

    result.gasRemaining = callContext->gas;
    if (SHOW_CALLS) {
        fRepeat(stderr, "\t", depthOf(callContext));
        fprintf(stderr, "gasUsed: %" PRIu64, startGas - callContext->gas);
        if (startGas < 600000000) {
            fprintf(stderr, " / %" PRIu64, startGas);
        }
        fputc('\n', stderr);
    }

    if (zero256(&result.status)) {
        evmRevert(&result.stateChanges);
    }

    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x8000(%rsi)
xorl %eax, %eax
movq %rax, 0x8048(%rsi)
movq %rax, 0x8058(%rsi)
movq %rax, 0x8068(%rsi)
movl $0x1, %esi
xorl %edi, %edi
callq 0x31b0
movq %rax, 0x8060(%r14)
movq 0x8080(%r14), %r15
leaq 0x17c5a(%rip), %r12     # 0x20a60
addq $0x8090, 0x2024000(%r12) # imm = 0x8090
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8edd
addq $-0x8090, 0x2024000(%r12) # imm = 0xFFFF7F70
movq 0x8080(%r14), %rdx
movq %rdx, 0x30(%rbx)
testb $0x20, 0x203bc2d(%rip)  # 0x2044a68
jne 0x8e6a
leaq 0x10(%rbx), %rdi
callq 0xc61a
testb %al, %al
je 0x8e5e
addq $0x38, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8e7e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x8080(%r14), %rsi
movq %r14, %rdi
movq %r15, %rcx
callq 0x3bec
jmp 0x8e3d
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/evm.c
// Function: evmRevert
static void evmRevert(stateChanges_t **changes) {
    if (*changes == NULL) {
        return;
    }
    account_t *account = getAccount((*changes)->account);
    evmRevertStorageChanges(account, &(*changes)->storageChanges);
    evmRevertLogChanges(&(*changes)->logChanges);

    evmRevert(&(*changes)->next);
    free(*changes);
    *changes = NULL;
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x8edc
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl 0x10(%rax), %ecx
movl %ecx, 0x10(%rsp)
movups (%rax), %xmm0
movups %xmm0, (%rsp)
callq 0x82de
movq (%rbx), %rsi
addq $0x20, %rsi
movq %rax, %rdi
callq 0xc3d3
movq (%rbx), %rdi
addq $0x18, %rdi
callq 0xc468
movq (%rbx), %rdi
addq $0x28, %rdi
callq 0x8e7e
movq (%rbx), %rdi
callq 0x3040
movq $0x0, (%rbx)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/evm.c
// Function: warmStorage
static storage_t *warmStorage(context_t *callContext, uint256_t *key, uint64_t warmGasCost) {
    account_t *account = callContext->account;
    storage_t *storage = getAccountStorage(account, key);
    if (storage->warm != evmIteration) {
        if (callContext->gas < warmGasCost) {
            return NULL;
        }
        callContext->gas -= warmGasCost;
        storage->warm = evmIteration;
        copy256(&storage->original, &storage->value);
    }
    return storage;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rdi, %r14
movq 0x8008(%rdi), %rdi
callq 0x84bb
movq %rax, %rbx
movq 0x204c802(%rip), %rax   # 0x2058a80
cmpq %rax, 0x60(%rbx)
je 0xc2af
movq 0x8080(%r14), %rcx
subq %r15, %rcx
jae 0xc294
xorl %ebx, %ebx
jmp 0xc2af
movq %rcx, 0x8080(%r14)
movq %rax, 0x60(%rbx)
leaq 0x40(%rbx), %rdi
movq %rbx, %rsi
addq $0x20, %rsi
callq 0xc649
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/evm.c
// Function: getAccountTransientStorage
static tstorage_t *getAccountTransientStorage(account_t *account, const uint256_t *key) {
    tstorage_t **tstorage = &account->tstorage;
    while (*tstorage != NULL) {
        if (equal256(&(*tstorage)->key, key)) {
            return *tstorage;
        }
        tstorage = &(*tstorage)->next;
    }
    *tstorage = calloc(1, sizeof(tstorage_t));
    copy256(&(*tstorage)->key, key);
    return *tstorage;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
addq $0x48, %rbx
testq %rdi, %rdi
je 0xc2e4
movq %r14, %rsi
callq 0xce67
testb %al, %al
jne 0xc301
movq (%rbx), %rbx
movq 0x48(%rbx), %rdi
jmp 0xc2c6
movl $0x1, %edi
movl $0x50, %esi
callq 0x31b0
movq %rax, (%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0xc649
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/evm.c
// Function: mergeStateChanges
static void mergeStateChanges(stateChanges_t **dst, stateChanges_t *src) {
    if (src == NULL) {
        return;
    }
    mergeStateChanges(dst, src->next);

    while (*dst != NULL) {
        if (AddressEqual(&src->account, &(*dst)->account)) {
            // merge!

            // concatenate the linked lists
            storageChanges_t **storageEnd = &src->storageChanges;
            while (*storageEnd != NULL) {
                storageEnd = &(*storageEnd)->prev;
            }
            *storageEnd = (*dst)->storageChanges;
            (*dst)->storageChanges = src->storageChanges;

            logChanges_t **logsEnd = &src->logChanges;
            while (*logsEnd != NULL) {
                logsEnd = &(*logsEnd)->prev;
            }
            *logsEnd = (*dst)->logChanges;
            (*dst)->logChanges = src->logChanges;

            return;
        }
        dst = &(*dst)->next;
    }
    // reuse src
    src->next = *dst;
    *dst = src;
}

// Assembly:
testq %rsi, %rsi
je 0xc3d2
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rsi), %rsi
callq 0xc30c
movq (%r14), %rax
testq %rax, %rax
je 0xc36f
movb (%rbx), %cl
cmpb (%rax), %cl
jne 0xc35c
movq $-0x1, %rdx
cmpq $0x12, %rdx
je 0xc37c
movb 0x2(%rbx,%rdx), %dil
leaq 0x1(%rdx), %rsi
cmpb 0x2(%rax,%rdx), %dil
movq %rsi, %rdx
je 0xc33d
cmpq $0x13, %rsi
jae 0xc37c
movq %rax, %r14
movq 0x28(%rax), %rdx
addq $0x28, %r14
movq %rdx, %rax
testq %rdx, %rdx
jne 0xc332
movq $0x0, 0x28(%rbx)
movq %rbx, (%r14)
jmp 0xc3cb
leaq 0x20(%rbx), %rdx
movq %rdx, %rcx
movq (%rdx), %rsi
leaq 0x68(%rsi), %rdx
testq %rsi, %rsi
jne 0xc380
movq 0x20(%rax), %rax
movq %rax, (%rcx)
movq 0x20(%rbx), %rax
movq (%r14), %rcx
movq %rax, 0x20(%rcx)
addq $0x18, %rbx
movq %rbx, %rcx
movq %rcx, %rax
movq (%rcx), %rdx
leaq 0x20(%rdx), %rcx
testq %rdx, %rdx
jne 0xc3a8
movq (%r14), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, (%rax)
movq (%rbx), %rax
movq (%r14), %rcx
movq %rax, 0x18(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/evm.c
// Function: evmRevertStorageChanges
static void evmRevertStorageChanges(account_t *account, storageChanges_t **changes) {
    if (*changes == NULL) {
        return;
    }
    storage_t *storage = getAccountStorage(account, &(*changes)->key);
    assert(equal256(&storage->value, &(*changes)->after));
    copy256(&storage->value, &(*changes)->before);
    storage->warm = (*changes)->warm;

    evmRevertStorageChanges(account, &(*changes)->prev);
    free(*changes);
    *changes = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rsi
testq %rsi, %rsi
je 0xc43d
movq %rdi, %r14
callq 0x84bb
movq %rax, %r15
leaq 0x20(%rax), %r12
movq (%rbx), %rsi
addq $0x40, %rsi
movq %r12, %rdi
callq 0xce67
testb %al, %al
je 0xc449
movq (%rbx), %rsi
addq $0x20, %rsi
movq %r12, %rdi
callq 0xc649
movq (%rbx), %rsi
movq 0x60(%rsi), %rax
movq %rax, 0x60(%r15)
addq $0x68, %rsi
movq %r14, %rdi
callq 0xc3d3
movq (%rbx), %rdi
callq 0x3040
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x67d3(%rip), %rdi      # 0x12c23
leaq 0x677c(%rip), %rsi      # 0x12bd3
leaq 0x67f3(%rip), %rcx      # 0x12c51
movl $0x611, %edx            # imm = 0x611
callq 0x3120
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/evm.c
// Function: evmRevertLogChanges
static void evmRevertLogChanges(logChanges_t **changes) {
    if (*changes == NULL) {
        return;
    }
    evmRevertLogChanges(&(*changes)->prev);

    free(*changes);
    *changes = NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xc48c
addq $0x20, %rdi
callq 0xc468
movq (%rbx), %rdi
callq 0x3040
movq $0x0, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/scan.c
// Function: scanInit
void scanInit() {
    programCounter = (uint32_t)-1;
    inDataSection = false;
    lineNumber = 1;
    labelQueueInit();
}

// Assembly:
movl $0xffffffff, 0x20495fa(%rip) # imm = 0xFFFFFFFF
movb $0x0, 0x20495f7(%rip)   # 0x2058e24
movl $0x1, 0x20495f1(%rip)   # 0x2058e28
movq $0x0, 0x20495ee(%rip) # 0x2058e30
leaq 0x20495e7(%rip), %rax   # 0x2058e30
movq %rax, 0x204edf0(%rip)   # 0x205e640
retq
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/scan.c
// Function: parseConstant
op_t parseConstant(const char **iter) {
    if (isHexConstantPrefix(*iter)) {
        *iter += 2;
        return parseHex(iter);
    } else {
        int negative = 0;
        while (parseNegative(iter)) {
            negative = !negative;
        }
        return parseDecimal(iter, negative);
    }
}

// Assembly:
movq (%rdi), %rax
movzwl (%rax), %ecx
cmpl $0x7830, %ecx           # imm = 0x7830
jne 0xfa49
addq $0x2, %rax
movq %rax, (%rdi)
jmp 0xfa6d
xorl %esi, %esi
cmpb $0x2d, %cl
jne 0xf862
incq %rax
xorl %esi, %esi
movq %rax, (%rdi)
xorl $0x1, %esi
cmpb $0x2d, (%rax)
leaq 0x1(%rax), %rax
je 0xfa59
jmp 0xf862
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/scan.c
// Function: parseHex
static op_t parseHex(const char **iter) {
    const char *start = *iter;
    while (isHex(**iter)) ++(*iter);
    uint8_t words = 0;
    const char *end = *iter;
    while (end > start) {
        words++;
        if (end - start >= 2) {
            end -= 2;
            scanstackPush((op_t)hexString16ToUint8(end));
        } else {
            --end;
            scanstackPush((op_t)hexString8ToUint8(*end));
        }
    }
    assert(words <= 32 || inDataSection);
    return (op_t)((PUSH1 - 1) + words);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r15
movb (%r15), %al
leal -0x3a(%rax), %ecx
cmpb $-0xb, %cl
ja 0xfa92
andb $-0x21, %al
addb $-0x47, %al
cmpb $-0x6, %al
jb 0xfbe4
leaq 0x1(%r15), %r12
movq %r12, (%rdi)
movb (%r12), %al
leal -0x3a(%rax), %ecx
incq %r12
cmpb $-0xb, %cl
ja 0xfa96
andb $-0x21, %al
addb $-0x47, %al
cmpb $-0x6, %al
jae 0xfa96
decq %r12
cmpq %r15, %r12
jbe 0xfbe4
xorl %ebx, %ebx
movq 0x8533(%rip), %rdx      # 0x17ff8
leaq 0x26df(%rip), %r14      # 0x121ab
leaq 0x204eb7d(%rip), %rbp   # 0x205e650
movq %r12, %rax
subq %r15, %rax
cmpq $0x2, %rax
jl 0xfafb
movzbl -0x2(%r12), %ecx
leal -0x30(%rcx), %r13d
cmpb $0xa, %r13b
jb 0xfb27
leal -0x61(%rcx), %eax
cmpb $0x5, %al
ja 0xfb1a
addb $-0x57, %cl
jmp 0xfb24
movzbl -0x1(%r12), %ecx
decq %r12
leal -0x30(%rcx), %r13d
cmpb $0xa, %r13b
jb 0xfb66
leal -0x61(%rcx), %eax
cmpb $0x5, %al
ja 0xfb40
addb $-0x57, %cl
jmp 0xfb4a
leal -0x41(%rcx), %eax
cmpb $0x5, %al
ja 0xfb87
addb $-0x37, %cl
movl %ecx, %r13d
movzbl -0x1(%r12), %ecx
leal -0x30(%rcx), %eax
cmpb $0xa, %al
jb 0xfb5b
leal -0x61(%rcx), %eax
cmpb $0x5, %al
ja 0xfb4f
addb $-0x57, %cl
jmp 0xfb59
leal -0x41(%rcx), %eax
cmpb $0x5, %al
ja 0xfba1
addb $-0x37, %cl
movl %ecx, %r13d
jmp 0xfb66
leal -0x41(%rcx), %eax
cmpb $0x5, %al
ja 0xfbc1
addb $-0x37, %cl
movl %ecx, %eax
addq $-0x2, %r12
shlb $0x4, %r13b
addb %al, %r13b
movzbl 0x20492bf(%rip), %eax   # 0x2058e2c
leal 0x1(%rax), %ecx
movb %cl, 0x20492b6(%rip)    # 0x2058e2c
movb %r13b, (%rax,%rbp)
incb %bl
cmpq %r15, %r12
ja 0xfad3
jmp 0xfbfa
movq (%rdx), %rdi
movq %r14, %rsi
movq %rdx, %r13
movl %ecx, %edx
xorl %eax, %eax
callq 0x31d0
movq %r13, %rdx
movb $-0x1, %r13b
jmp 0xfb27
movq (%rdx), %rdi
movq %r14, %rsi
movq %r14, %r13
movq %rdx, %r14
movl %ecx, %edx
xorl %eax, %eax
callq 0x31d0
movq %r14, %rdx
movq %r13, %r14
movb $-0x1, %r13b
jmp 0xfb66
movq (%rdx), %rdi
movq %r14, %rsi
movq %rdx, %r14
movl %ecx, %edx
xorl %eax, %eax
callq 0x31d0
movq %r14, %rdx
leaq 0x25ce(%rip), %r14      # 0x121ab
movb $-0x1, %al
jmp 0xfb5b
xorl %ebx, %ebx
addb $0x5f, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x21, %bl
jb 0xfbe6
cmpb $0x0, 0x204921e(%rip)   # 0x2058e24
jne 0xfbe6
leaq 0x45d3(%rip), %rdi      # 0x141e2
leaq 0x45e9(%rip), %rsi      # 0x141ff
leaq 0x45ed(%rip), %rcx      # 0x1420a
movl $0x42, %edx
callq 0x3120
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/scan.c
// Function: scanNextOp
op_t scanNextOp(const char **iter) {
    jump_t jump;
    programCounter++;
    jump.programCounter = programCounter;
    if (scanstackEmpty()) {
        scanOp(iter);
    }
    if (scanstackTopLabel(&jump.label)) {
        op_t type = scanstackPop();
        if (type == JUMPDEST) {
            jump.dataSize = 1;
            registerLabel(jump);
            return type;
        } else if (type == CODECOPY) {
            // because we can one data entry at a time, the stack size is the dataSize
            jump.dataSize = scanstackIndex;
            registerLabel(jump);
            return scanstackPop();
        } else if (type == CODESIZE) {
            jump.len = 1;
            labelQueuePush(jump, type);
            return type;
        } else {
            jump.len = 1;
            labelQueuePush(jump, type);
            return type;
        }
    } else return scanstackPop();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl 0x20491ec(%rip), %eax   # 0x2058e20
incl %eax
movl %eax, 0x20491e4(%rip)   # 0x2058e20
movl %eax, 0x28(%rsp)
movb 0x20491e6(%rip), %al    # 0x2058e2c
testb %al, %al
jne 0xfc55
callq 0xfdb2
movb 0x20491d7(%rip), %al    # 0x2058e2c
movzbl %al, %ebx
leaq 0x204edf1(%rip), %r14   # 0x205ea50
movq (%r14,%rbx,8), %rdi
testq %rdi, %rdi
je 0xfcd2
movups (%rdi), %xmm0
movups %xmm0, 0x38(%rsp)
callq 0x3040
movq $0x0, (%r14,%rbx,8)
leal -0x1(%rbx), %eax
movb %al, 0x20491a6(%rip)    # 0x2058e2c
movzbl %al, %eax
leaq 0x204e9c0(%rip), %r14   # 0x205e650
movzbl (%rax,%r14), %ebx
cmpl $0x38, %ebx
je 0xfd23
cmpl $0x39, %ebx
je 0xfcec
cmpl $0x5b, %ebx
jne 0xfd68
movw $0x1, 0x2c(%rsp)
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x10273
movb $0x5b, %bl
jmp 0xfda8
decb %bl
movb %bl, 0x2049152(%rip)    # 0x2058e2c
movzbl %bl, %eax
leaq 0x204e96c(%rip), %rcx   # 0x205e650
movb (%rax,%rcx), %bl
jmp 0xfda8
movw %ax, 0x2c(%rsp)
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x10273
movb 0x204911d(%rip), %al    # 0x2058e2c
decb %al
movb %al, 0x2049115(%rip)    # 0x2058e2c
movzbl %al, %eax
movb (%rax,%r14), %bl
jmp 0xfda8
movb $0x1, 0x2e(%rsp)
movl $0x30, %edi
callq 0x3200
movq 0x204e907(%rip), %rcx   # 0x205e640
movq %rax, (%rcx)
leaq 0x28(%rax), %rcx
movq $0x0, 0x28(%rax)
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movb $0x38, 0x20(%rax)
movq %rcx, 0x204e8dc(%rip)   # 0x205e640
movb $0x38, %bl
jmp 0xfda8
movb $0x1, 0x2e(%rsp)
movl $0x30, %edi
callq 0x3200
movq 0x204e8c2(%rip), %rcx   # 0x205e640
movq %rax, (%rcx)
leaq 0x28(%rax), %rcx
movq $0x0, 0x28(%rax)
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movb %bl, 0x20(%rax)
movq %rcx, 0x204e898(%rip)   # 0x205e640
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/scan.c
// Function: fprintLabels
void fprintLabels(FILE *stream) {
    fputc('{', stream);
    for (uint32_t i = 0; i < labelCount; i++) {
        if (i) {
            fputc(',', stream);
        }
        fputc('\n', stream);
        fputc('\t', stream);
        fputc('"', stream);
        fprintLabel(stream, labels + i);
        fputc('"', stream);
        fprintf(stream, ": \"0x%04x\"", labelLocations[i]);
    }
    if (labelCount) {
        fputc('\n', stream);
    }
    fputc('}', stream);
    fputc('\n', stream);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x7b, %edi
movq %rbx, %rsi
callq 0x3180
cmpl $0x0, 0x20488db(%rip)   # 0x2058e38
je 0x10624
leaq 0x20488d6(%rip), %r15   # 0x2058e40
leaq 0x3c66(%rip), %r14      # 0x141d7
xorl %r13d, %r13d
testq %r13, %r13
je 0x10586
movl $0x2c, %edi
movq %rbx, %rsi
callq 0x3180
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3180
movl $0x9, %edi
movq %rbx, %rsi
callq 0x3180
movl $0x22, %edi
movq %rbx, %rsi
callq 0x3180
movq %r13, %rbp
shlq $0x4, %rbp
cmpq $0x0, 0x8(%rbp,%r15)
je 0x105dc
addq %r15, %rbp
xorl %r12d, %r12d
movq (%rbp), %rax
movsbl (%rax,%r12), %edi
movq %rbx, %rsi
callq 0x3180
incq %r12
cmpq 0x8(%rbp), %r12
jb 0x105c2
movl $0x22, %edi
movq %rbx, %rsi
callq 0x3180
leaq 0x204d050(%rip), %rax   # 0x205d640
movl (%rax,%r13,4), %edx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x31d0
incq %r13
movl 0x204882e(%rip), %eax   # 0x2058e38
cmpq %rax, %r13
jb 0x10574
testl %eax, %eax
je 0x10624
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3180
movl $0x7d, %edi
movq %rbx, %rsi
callq 0x3180
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3180
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/scan.c
// Function: scanWaste
static inline char scanWaste(const char **iter) {
    char ch;
    for (; shouldIgnore(ch = **iter) && ch; (*iter)++) {
        if (ch == '\n') {
            lineNumber++;
        }
    }
    if (ch == '/') {
        scanComment(iter);
        return scanWaste(iter);
    }
    return ch;
}

// Assembly:
movq (%rdi), %rdx
movl 0x20487d3(%rip), %eax   # 0x2058e28
movabsq $0x400330800000000, %rcx # imm = 0x400330800000000
movzbl (%rdx), %esi
cmpq $0x3a, %rsi
ja 0x10674
cmpq $0x2f, %rsi
je 0x106c3
btq %rsi, %rcx
jb 0x106df
cmpl $0x7b, %esi
je 0x106df
cmpl $0x7d, %esi
je 0x106df
leal -0x3a(%rsi), %r8d
cmpb $-0xb, %r8b
ja 0x106df
leal -0x5b(%rsi), %r8d
cmpb $-0x1b, %r8b
ja 0x106df
leal -0x7b(%rsi), %r8d
cmpb $-0x1a, %r8b
setae %r8b
testb %sil, %sil
sete %r9b
orb %r8b, %r9b
jne 0x106bd
cmpb $0xa, %sil
jne 0x106b8
incl %eax
movl %eax, 0x2048770(%rip)   # 0x2058e28
incq %rdx
jmp 0x106da
cmpb $0x2f, %sil
jne 0x106df
incq %rdx
movq %rdx, (%rdi)
cmpb $0xa, (%rdx)
leaq 0x1(%rdx), %rdx
jne 0x106c6
incl %eax
movl %eax, 0x204874e(%rip)   # 0x2058e28
movq %rdx, (%rdi)
jmp 0x1065f
retq
// File: /workspace/github_c_makefile_star2_O3/wjmelements[P]evm/src/scan.c
// Function: scanLabel
static void scanLabel(const char **iter) {
    const char *start = *iter;
    for (char ch; isLowerCase(**iter); (*iter)++);
    const char *end = *iter;
    char next = scanWaste(iter);
    if (next == ':') {
        (*iter)++;
        scanstackPushLabel(start, end - start, JUMPDEST);
    } else {
        scanstackPushLabel(start, end - start, STOP);
        scanstackPush(PUSH1);
    }
    scanWaste(iter);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
movb (%r15), %al
addb $-0x7b, %al
movq %r15, %r12
cmpb $-0x1a, %al
jb 0x10711
leaq 0x1(%r15), %r12
movq %r12, (%rbx)
movb (%r12), %al
addb $-0x7b, %al
incq %r12
cmpb $-0x1a, %al
jae 0x106fe
decq %r12
movl 0x2048711(%rip), %ebp   # 0x2058e28
movabsq $0x330800000000, %rax   # imm = 0x330800000000
movq %r12, %r14
movzbl (%r14), %ecx
cmpq $0x3a, %rcx
ja 0x10744
cmpq $0x2f, %rcx
je 0x10791
btq %rcx, %rax
jb 0x107fb
cmpq $0x3a, %rcx
je 0x107b6
cmpl $0x7b, %ecx
je 0x107fb
cmpl $0x7d, %ecx
je 0x107fb
leal -0x3a(%rcx), %edx
cmpb $-0xb, %dl
ja 0x107b1
leal -0x5b(%rcx), %edx
cmpb $-0x1b, %dl
ja 0x107b1
leal -0x7b(%rcx), %edx
cmpb $-0x1a, %dl
setae %dl
testl %ecx, %ecx
sete %sil
orb %dl, %sil
jne 0x1078c
cmpl $0xa, %ecx
jne 0x10787
incl %ebp
movl %ebp, 0x20486a1(%rip)   # 0x2058e28
incq %r14
jmp 0x107a9
cmpl $0x2f, %ecx
jne 0x107b1
incq %r14
movq %r14, (%rbx)
cmpb $0xa, (%r14)
leaq 0x1(%r14), %r14
jne 0x10794
incl %ebp
movl %ebp, 0x204867f(%rip)   # 0x2058e28
movq %r14, (%rbx)
jmp 0x10724
cmpl $0x3a, %ecx
jne 0x107fb
incq %r14
movq %r14, (%rbx)
subq %r15, %r12
movl $0x10, %edi
callq 0x3200
movq %r15, (%rax)
movq %r12, 0x8(%rax)
movzbl 0x2048655(%rip), %ecx   # 0x2058e2c
leal 0x1(%rcx), %edx
movb %dl, 0x204864c(%rip)    # 0x2058e2c
leaq 0x204de69(%rip), %rsi   # 0x205e650
movb $0x5b, (%rcx,%rsi)
movzbl %dl, %ecx
leaq 0x204e25b(%rip), %rdx   # 0x205ea50
movq %rax, (%rdx,%rcx,8)
jmp 0x1083f
subq %r15, %r12
movl $0x10, %edi
callq 0x3200
movq %r15, (%rax)
movq %r12, 0x8(%rax)
movzbl 0x2048616(%rip), %ecx   # 0x2058e2c
leal 0x1(%rcx), %edx
leaq 0x204de30(%rip), %rsi   # 0x205e650
movb $0x0, (%rcx,%rsi)
movzbl %dl, %edx
leaq 0x204e222(%rip), %rdi   # 0x205ea50
movq %rax, (%rdi,%rdx,8)
leal 0x2(%rcx), %eax
movb %al, 0x20485f1(%rip)    # 0x2058e2c
movb $0x60, (%rdx,%rsi)
movabsq $0x400330800000000, %rax # imm = 0x400330800000000
movzbl (%r14), %ecx
cmpq $0x3a, %rcx
ja 0x1085f
cmpq $0x2f, %rcx
je 0x108a4
btq %rcx, %rax
jb 0x108c1
cmpl $0x7b, %ecx
je 0x108c1
cmpl $0x7d, %ecx
je 0x108c1
leal -0x3a(%rcx), %edx
cmpb $-0xb, %dl
ja 0x108c1
leal -0x5b(%rcx), %edx
cmpb $-0x1b, %dl
ja 0x108c1
leal -0x7b(%rcx), %edx
cmpb $-0x1a, %dl
setae %dl
testb %cl, %cl
sete %sil
orb %dl, %sil
jne 0x1089f
cmpb $0xa, %cl
jne 0x1089a
incl %ebp
movl %ebp, 0x204858e(%rip)   # 0x2058e28
incq %r14
jmp 0x108bc
cmpb $0x2f, %cl
jne 0x108c1
incq %r14
movq %r14, (%rbx)
cmpb $0xa, (%r14)
leaq 0x1(%r14), %r14
jne 0x108a7
incl %ebp
movl %ebp, 0x204856c(%rip)   # 0x2058e28
movq %r14, (%rbx)
jmp 0x10849
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq