LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movq (%rdi), %r12
movq 0x194a7(%rip), %rbx     # 0x1ea48
incq %r12
movsbl -0x1(%r12), %r15d
cmpb %bpl, %r15b
je 0x55d0
movl %r15d, %edi
callq 0x5905
testl %eax, %eax
je 0x55dc
cmpb $0xa, %r15b
jne 0x55cb
incq %rbx
movq %rbx, 0x1947d(%rip)     # 0x1ea48
movq %r12, (%r14)
jmp 0x55a1
movq %r12, (%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movzbl %bpl, %edx
movq 0x10a11(%rip), %rax     # 0x15ff8
movq (%rax), %rdi
leaq 0x9c14(%rip), %rsi      # 0xf205
movl %r15d, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0x31d0
pushq $0x1
popq %rdi
callq 0x3080
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/src/dio.c
// Function: jsonSkipExpectedChar
static void jsonSkipExpectedChar(const char **iter, char expected) {
    if (**iter == expected) {
        (*iter)++;
    } else {
        fprintf(stderr, "Config: expecting '%c', found '%c' on line %" PRIu64 "\n", expected, **iter, lineNumber);
        _exit(1);
    }
}

// Assembly:
movq (%rdi), %rax
movsbl (%rax), %ecx
cmpb %sil, %cl
jne 0x5660
incq %rax
movq %rax, (%rdi)
retq
pushq %rax
movzbl %sil, %edx
movq 0x1098c(%rip), %rax     # 0x15ff8
movq (%rax), %rdi
movq 0x193d2(%rip), %r8      # 0x1ea48
leaq 0x9e49(%rip), %rsi      # 0xf4c6
xorl %eax, %eax
callq 0x31d0
pushq $0x1
popq %rdi
callq 0x3080
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/src/dio.c
// Function: jsonIgnores
static inline int jsonIgnores(char ch) {
    return ch != '{'
        && ch != '}'
        && ch != '['
        && ch != ']'
        && ch != ','
        && ch != ':'
        && ch != '"'
        && (ch < '0' || ch > '9')
        && (ch < 'A' || ch > 'Z')
        && (ch < 'a' || ch > 'z')
    ;
}

// Assembly:
xorl %eax, %eax
leal -0x22(%rdi), %ecx
cmpl $0x3b, %ecx
ja 0x5920
movabsq $0xa00000001000401, %rdx # imm = 0xA00000001000401
btq %rcx, %rdx
jae 0x5920
retq
cmpl $0x7b, %edi
je 0x591f
cmpl $0x7d, %edi
je 0x591f
leal -0x3a(%rdi), %ecx
cmpb $-0xa, %cl
setae %cl
leal -0x5b(%rdi), %edx
cmpb $-0x1a, %dl
setae %dl
orb %cl, %dl
jne 0x591f
addb $-0x7b, %dil
xorl %eax, %eax
cmpb $-0x1a, %dil
setb %al
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x22
popq %rsi
callq 0x558a
movq (%rbx), %r14
leaq 0x1(%r14), %rax
movzbl -0x1(%rax), %ecx
cmpl $0x22, %ecx
je 0x5979
testl %ecx, %ecx
je 0x5979
movq %rax, (%rbx)
incq %rax
jmp 0x5964
pushq $0x22
popq %rsi
movq %rbx, %rdi
callq 0x564e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x22
popq %rbp
movl %ebp, %esi
callq 0x564e
movq %rbx, %rdi
callq 0x5a58
movq %rax, %r14
movq %rbx, %rdi
movl %ebp, %esi
callq 0x564e
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/include/address.h
// Function: AddressFromHex40
static inline address_t AddressFromHex40(const char *hex) {
    address_t address;
    for (uint8_t i = 0; i < 40; i += 2) {
        address.address[i >> 1] = hexString16ToUint8(hex+i);
    }
    return address;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %ebp, %ebp
movzbl %bpl, %ebp
cmpl $0x28, %ebp
jae 0x5a50
movl %ebp, %edi
addq %r14, %rdi
callq 0x59fe
movl %ebp, %ecx
shrl %ecx
movb %al, (%rbx,%rcx)
addl $0x2, %ebp
jmp 0x5a31
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x30
popq %rsi
callq 0x564e
pushq $0x78
popq %rsi
movq %rbx, %rdi
callq 0x564e
pushq $0x14
popq %rdi
callq 0x3200
movq %rax, %r14
xorl %r15d, %r15d
cmpq $0x14, %r15
je 0x5a9c
movq (%rbx), %rdi
callq 0x59fe
movb %al, (%r14,%r15)
addq $0x2, (%rbx)
incq %r15
jmp 0x5a81
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq 0x38(%rsi), %rdx
testq %rdx, %rdx
je 0x5ad8
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rdx, (%rdi)
jne 0x5ae7
movq 0x8(%r14), %rdi
movq 0x40(%rbx), %rsi
callq 0x3210
testl %eax, %eax
jne 0x5ae7
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1050a(%rip), %rax     # 0x15ff8
movq (%rax), %rsi
leaq 0x981e(%rip), %rdi      # 0xf316
callq 0x3130
movq (%rbx), %rax
movzbl (%rax), %edx
movzbl 0x1(%rax), %ecx
movzbl 0x2(%rax), %r8d
movzbl 0x3(%rax), %r9d
movzbl 0x4(%rax), %esi
movq %rsi, 0x50(%rsp)
movzbl 0x5(%rax), %esi
movq %rsi, 0x48(%rsp)
movzbl 0x6(%rax), %esi
movq %rsi, 0x40(%rsp)
movzbl 0x7(%rax), %esi
movq %rsi, 0x38(%rsp)
movzbl 0x8(%rax), %esi
movq %rsi, 0x30(%rsp)
movzbl 0x9(%rax), %esi
movq %rsi, 0x28(%rsp)
movzbl 0xa(%rax), %esi
movq %rsi, 0x20(%rsp)
movzbl 0xb(%rax), %esi
movq %rsi, 0x18(%rsp)
movzbl 0xc(%rax), %esi
movq %rsi, 0x10(%rsp)
movzbl 0xd(%rax), %esi
movq %rsi, 0x8(%rsp)
movzbl 0xe(%rax), %ebp
movzbl 0xf(%rax), %r13d
movzbl 0x10(%rax), %r12d
movzbl 0x11(%rax), %r15d
movzbl 0x12(%rax), %r11d
movzbl 0x13(%rax), %r10d
movq 0x10469(%rip), %rax     # 0x15ff8
movq (%rax), %rdi
leaq 0x9797(%rip), %rsi      # 0xf330
xorl %eax, %eax
pushq %r10
pushq %r11
pushq %r15
pushq %r12
pushq %r13
pushq %rbp
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)
callq 0x31d0
addq $0x80, %rsp
movq 0x10408(%rip), %r15     # 0x15ff8
movq (%r15), %rdi
movq 0x18e5e(%rip), %rdx     # 0x1ea58
movq 0x58(%rbx), %rcx
leaq 0x977e(%rip), %rsi      # 0xf383
xorl %eax, %eax
callq 0x31d0
movq (%r15), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x6286
movq (%r15), %rcx
leaq 0x976d(%rip), %rdi      # 0xf392
pushq $0xb
popq %rsi
pushq $0x1
popq %rdx
callq 0x3290
movq (%r15), %rdi
movq 0x38(%rbx), %rsi
movq 0x40(%rbx), %rdx
callq 0x6286
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x3180
pushq $-0x1
popq %rdi
callq 0x3080
// File: /workspace/github_c_makefile_star2_O2/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 0x635f
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rsi), %rsi
callq 0x6310
movl %eax, %ebx
testw %ax, %ax
je 0x6343
pushq $0x2c
popq %rdi
movq %r14, %rsi
callq 0x3180
testl %ebp, %ebp
je 0x6366
movzwl 0xa(%r15), %edx
leaq 0x95e9(%rip), %rsi      # 0xf93c
movq %r14, %rdi
xorl %eax, %eax
callq 0x31d0
jmp 0x637b
xorl %ebx, %ebx
jmp 0x6418
leaq 0x95ed(%rip), %rdi      # 0xf95a
pushq $0xb
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x3290
leaq 0x8ffc(%rip), %r12      # 0xf37e
xorl %r13d, %r13d
cmpq 0x10(%r15), %r13
jae 0x63a6
movq 0x18(%r15), %rax
movzbl (%rax,%r13), %edx
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x31d0
incq %r13
jmp 0x6385
leaq 0x95b9(%rip), %rdi      # 0xf966
movq %r14, %rsi
callq 0x3130
movzbl 0x8(%r15), %r13d
shll $0x5, %r13d
leaq 0x95ae(%rip), %r12      # 0xf973
pushq $0x2c
popq %rbp
testq %r13, %r13
je 0x6407
movq (%r15), %rax
movq -0x20(%rax,%r13), %rdx
movq -0x18(%rax,%r13), %rcx
movq -0x10(%rax,%r13), %r8
movq -0x8(%rax,%r13), %r9
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x31d0
cmpq $0x20, %r13
je 0x6401
movl %ebp, %edi
movq %r14, %rsi
callq 0x3180
addq $-0x20, %r13
jmp 0x63c8
leaq 0x9582(%rip), %rdi      # 0xf990
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_O2/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 0x92f6(%rip), %rdi      # 0xf9ba
movq %r15, %rsi
callq 0x3130
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x66f2
movl %eax, %ebx
leaq 0x8ac7(%rip), %rdi      # 0xf1a9
movq %r15, %rsi
callq 0x3130
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6871
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq 0x28(%rsi), %rsi
callq 0x66f2
movl %eax, %ebx
cmpq $0x0, 0x18(%r15)
je 0x6873
movl %ebp, 0xc(%rsp)
testw %bx, %bx
je 0x673b
pushq $0x2c
popq %rdi
movq %r14, %rsi
callq 0x3180
leaq 0x8a54(%rip), %rdi      # 0xf196
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 0x8b45(%rip), %rsi      # 0xf330
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 0x9125(%rip), %rdi      # 0xf96f
movq %r14, %rsi
callq 0x3130
movq 0x18(%r15), %rsi
movq %r14, %rdi
movl 0xc(%rsp), %edx
callq 0x6310
addl %eax, %ebx
pushq $0x5d
popq %rdi
movq %r14, %rsi
callq 0x3180
jmp 0x6873
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_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x38, %r14
movq (%r14), %r15
testq %r15, %r15
je 0x68b7
movq 0x8008(%rbx), %rsi
movq %r15, %rdi
callq 0x68de
leaq 0x28(%r15), %r14
testl %eax, %eax
je 0x6893
movq %r15, %rax
jmp 0x68d8
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x31b0
movq %rax, (%r14)
movq 0x8008(%rbx), %rcx
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/include/address.h
// Function: AddressEqual
static inline int AddressEqual(const address_t *expected, const address_t *actual) {
    for (int i = 0; i < 20; i ++) {
        if (expected->address[i] != actual->address[i]) {
            return 0;
        }
    }
    return 1;
}

// Assembly:
xorl %eax, %eax
movq %rax, %rcx
cmpq $0x14, %rax
je 0x68f5
movb (%rdi,%rcx), %dl
leaq 0x1(%rcx), %rax
cmpb (%rsi,%rcx), %dl
je 0x68e0
xorl %eax, %eax
cmpq $0x14, %rcx
setae %al
retq
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/src/evm.c
// Function: evmInit
void evmInit() {
    callstack.next = callstack.bottom;
    while (emptyAccount --> accounts) {
        storage_t *storage = emptyAccount->storage;
        while (storage != NULL) {
            void *toFree = storage;
            storage = storage->next;
            free(toFree);
        }
        tstorage_t *tstorage = emptyAccount->tstorage;
        while (tstorage != NULL) {
            void *toFree = tstorage;
            tstorage = tstorage->next;
            free(toFree);
        }
        emptyAccount->storage = NULL;
        emptyAccount->tstorage = NULL;
        emptyAccount->warm = 0;
        bzero(emptyAccount->address.address, 20);
        op_t *code = emptyAccount->code.content;
        if (code != NULL) {
            free(code);
        }
        emptyAccount->code.content = NULL;
    }
    emptyAccount = accounts;
    evmIteration++;
    refundCounter = 0;
    logIndex = 0;
    coinbase = AddressFromHex42("0x4838B106FCe9647Bdf1E7877BF73cE8B0BAD5f97");
    account_t *coinbaseAccount = getAccount(coinbase);
    coinbaseAccount->balance[0] = 0x1;
    coinbaseAccount->balance[1] = 0xd82f5899;
    coinbaseAccount->balance[2] = 0x461084bd;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x180fb(%rip), %rax     # 0x1ea60
movq %rax, 0x2024000(%rax)
movq 0x203c0fd(%rip), %r14   # 0x2042a70
leaq 0x203c106(%rip), %rbx   # 0x2042a80
leaq -0x50(%r14), %rax
movq %rax, 0x203c0eb(%rip)   # 0x2042a70
cmpq %rbx, %r14
jbe 0x69ec
movq -0x10(%r14), %rdi
testq %rdi, %rdi
je 0x69a1
movq 0x68(%rdi), %r14
callq 0x3040
movq %r14, %rdi
jmp 0x698e
movq 0x203c0c8(%rip), %rax   # 0x2042a70
movq 0x48(%rax), %rdi
testq %rdi, %rdi
je 0x69bf
movq 0x48(%rdi), %r14
callq 0x3040
movq %r14, %rdi
jmp 0x69ac
movq 0x203c0aa(%rip), %r14   # 0x2042a70
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andl $0x0, 0x10(%r14)
movups %xmm0, 0x38(%r14)
andq $0x0, 0x48(%r14)
movq 0x28(%r14), %rdi
callq 0x3040
andq $0x0, 0x28(%r14)
jmp 0x697a
incq 0x205008d(%rip)         # 0x2056a80
andq $0x0, 0x205008d(%rip)   # 0x2056a88
andw $0x0, 0x205008d(%rip)   # 0x2056a90
movq %rbx, 0x203c066(%rip)   # 0x2042a70
xorl %r14d, %r14d
leaq 0x8fa8(%rip), %r15      # 0xf9bc
movzbl %r14b, %r14d
cmpl $0x27, %r14d
ja 0x6a4a
movzbl 0x2(%r14,%r15), %edi
callq 0x75ed
movl %eax, %ebx
shlb $0x4, %bl
movzbl 0x3(%r14,%r15), %edi
callq 0x75ed
addb %bl, %al
movl %r14d, %ecx
shrl %ecx
movb %al, 0x18(%rsp,%rcx)
addl $0x2, %r14d
jmp 0x6a14
movl 0x28(%rsp), %eax
movl %eax, 0x2050054(%rip)   # 0x2056aa8
movups 0x18(%rsp), %xmm0
movups %xmm0, 0x2050038(%rip)  # 0x2056a98
movl 0x2050042(%rip), %eax   # 0x2056aa8
movl %eax, 0x10(%rsp)
movups 0x2050027(%rip), %xmm0  # 0x2056a98
movups %xmm0, (%rsp)
callq 0x6a99
movabsq $-0x27d0a766ffffffff, %rcx # imm = 0xD82F589900000001
movq %rcx, 0x14(%rax)
movl $0x461084bd, 0x1c(%rax) # imm = 0x461084BD
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/src/evm.c
// Function: evmMockBalance
void evmMockBalance(address_t from, const val_t balance) {
    account_t *account = getAccount(from);
    account->balance[0] = balance[0];
    account->balance[1] = balance[1];
    account->balance[2] = balance[2];
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl 0x40(%rsp), %eax
movl %eax, 0x10(%rsp)
movaps 0x30(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x6a99
movl (%rbx), %ecx
movl %ecx, 0x14(%rax)
movl 0x4(%rbx), %ecx
movl %ecx, 0x18(%rax)
movl 0x8(%rbx), %ecx
movl %ecx, 0x1c(%rax)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
addq $0x40, %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6d6d
movq %r14, %rsi
callq 0xa648
testb %al, %al
jne 0x6d86
movq (%rbx), %rbx
addq $0x68, %rbx
jmp 0x6d50
pushq $0x1
popq %rdi
pushq $0x70
popq %rsi
callq 0x31b0
movq %rax, (%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x9ee4
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/src/evm.c
// Function: calldataGas
static inline uint64_t calldataGas(const data_t *calldata, bool isCreate) {
    uint64_t gas = 0;
    gas += G_CALLDATAZERO * calldata->size;
    if (isCreate) {
        gas += G_INITCODEWORD * ((calldata->size + 31) >> 5); // EIP 3860: 2 gas per word
    }
    for (size_t i = 0; i < calldata->size; i++) {
        if (calldata->content[i]) {
            gas += G_CALLDATANONZERO;
        }
    }
    return gas;
}

// Assembly:
movq (%rdi), %rcx
leaq 0x1f(%rcx), %rax
shrq $0x4, %rax
andq $-0x2, %rax
xorl %edx, %edx
testl %esi, %esi
cmoveq %rdx, %rax
leaq (%rax,%rcx,4), %rax
cmpq %rdx, %rcx
je 0x7213
movq 0x8(%rdi), %rsi
cmpb $0x0, (%rsi,%rdx)
leaq 0xc(%rax), %rsi
cmovneq %rsi, %rax
incq %rdx
jmp 0x71f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6a99
movq %rax, %rbp
movq 0x204f4ec(%rip), %rax   # 0x2056a80
movq %rax, 0x38(%rbp)
movl 0x204f50a(%rip), %eax   # 0x2056aa8
movl %eax, 0x10(%rsp)
movups 0x204f4ef(%rip), %xmm0  # 0x2056a98
movups %xmm0, (%rsp)
callq 0x6a99
movq 0x204f4c7(%rip), %rcx   # 0x2056a80
movq %rcx, 0x38(%rax)
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %rbx, %r9
callq 0x73a9
incq 0x204f4a5(%rip)         # 0x2056a80
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_O2/wjmelements[P]evm/src/evm.c
// Function: BalanceAdd
static inline void BalanceAdd(val_t to, val_t amount) {
    uint32_t carry = 0;
    uint8_t i = 3;
    while (i --> 0) {
        uint32_t result = carry + to[i] + amount[i];
        if (result < amount[i]) {
            carry = 1;
        } else {
            carry = 0;
        }
        to[i] = result;
    }
}

// Assembly:
xorl %ecx, %ecx
pushq $0x2
popq %rax
cmpq $-0x1, %rax
je 0x7686
movzbl %al, %edx
shll $0x2, %edx
addl (%rdi,%rdx), %ecx
xorl %r8d, %r8d
addl (%rsi,%rdx), %ecx
setb %r8b
movl %ecx, (%rdi,%rdx)
decq %rax
movl %r8d, %ecx
jmp 0x7662
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rsi, 0x8000(%rsi)
andq $0x0, 0x8048(%rsi)
andq $0x0, 0x8058(%rsi)
movq %rdi, %rbx
andq $0x0, 0x8068(%rsi)
pushq $0x1
popq %rsi
xorl %edi, %edi
callq 0x31b0
movq %rax, 0x8060(%r15)
movq 0x8080(%r15), %r14
leaq 0x1738c(%rip), %r13     # 0x1ea60
addq $0x8090, 0x2024000(%r13) # imm = 0x8090
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7825
addq $-0x8090, 0x2024000(%r13) # imm = 0xFFFF7F70
movq 0x8080(%r15), %rax
movq %rax, 0x30(%rbx)
testb $0x20, 0x203b361(%rip)  # 0x2042a68
jne 0x772f
leaq 0x10(%rbx), %rdi
callq 0x9eb5
testb %al, %al
je 0x7722
movq %rbx, %rdi
addq $0x38, %rdi
callq 0x77c9
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xe8c2(%rip), %r12      # 0x15ff8
movq (%r12), %rdi
movq %r15, %rax
subq %r13, %rax
movl $0x8090, %ecx           # imm = 0x8090
cqto
idivq %rcx
movzwl %ax, %edx
leaq 0x830a(%rip), %rsi      # 0xfa5e
callq 0x6917
movq (%r12), %rdi
movq %r14, %rdx
subq 0x8080(%r15), %rdx
leaq 0x82f2(%rip), %rsi      # 0xfa60
xorl %eax, %eax
callq 0x31d0
cmpq $0x23c345ff, %r14       # imm = 0x23C345FF
jbe 0x778f
movq (%r12), %rsi
pushq $0xa
popq %rdi
callq 0x3180
jmp 0x7709
movq (%r12), %rdi
leaq 0x82d3(%rip), %rsi      # 0xfa6d
movq %r14, %rdx
xorl %eax, %eax
callq 0x31d0
jmp 0x777e
// File: /workspace/github_c_makefile_star2_O2/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 0x7824
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl 0x10(%rax), %ecx
movl %ecx, 0x10(%rsp)
movups (%rax), %xmm0
movups %xmm0, (%rsp)
callq 0x6a99
movq (%rbx), %rsi
addq $0x20, %rsi
movq %rax, %rdi
callq 0x9ca9
movq (%rbx), %rdi
addq $0x18, %rdi
callq 0x9d3b
movq (%rbx), %rdi
addq $0x28, %rdi
callq 0x77c9
movq (%rbx), %rdi
callq 0x3040
andq $0x0, (%rbx)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/src/evm.c
// Function: ensureMemory
static inline bool ensureMemory(context_t *callContext, uint64_t capacity) {
    memory_t *memory = &callContext->memory;
    if (memory->num_uint8s < capacity) {
        uint64_t memoryGas = memoryGasCost(capacity) - memoryGasCost(memory->num_uint8s);
        if (memoryGas > callContext->gas) {
            return false;
        }
        callContext->gas -= memoryGas;
        memory_ensure(memory, capacity);
        memory->num_uint8s = capacity;
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8058(%rdi), %r12
movb $0x1, %bl
cmpq %rsi, %r12
jae 0x9ab0
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x9c7b
movq %rax, %r13
movq %r12, %rdi
callq 0x9c7b
subq %rax, %r13
movq 0x8080(%r15), %rax
subq %r13, %rax
jae 0x9a60
xorl %ebx, %ebx
jmp 0x9ab0
movq %rax, 0x8080(%r15)
cmpq %r14, 0x8068(%r15)
jae 0x9aa9
movq %r14, 0x8068(%r15)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x31b0
movq %rax, %r13
movq 0x8060(%r15), %rbp
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x31f0
movq %rbp, %rdi
callq 0x3040
movq %r13, 0x8060(%r15)
movq %r14, 0x8058(%r15)
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_O2/wjmelements[P]evm/src/evm.c
// Function: warmAccount
static account_t *warmAccount(context_t *callContext, const address_t address) {
    account_t *account = getAccount(address);
    if (account->warm != evmIteration) {
        uint64_t gasCost = G_COLD_ACCOUNT - G_ACCESS;
        if (callContext->gas < gasCost) {
            return NULL;
        }
        callContext->gas -= gasCost;
        account->warm = evmIteration;
    }
    return account;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl 0x40(%rsp), %eax
movl %eax, 0x10(%rsp)
movaps 0x30(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x6a99
movq 0x204cf9a(%rip), %rcx   # 0x2056a80
cmpq %rcx, 0x38(%rax)
je 0x9b12
movq 0x8080(%rbx), %rdx
cmpq $0x9c4, %rdx            # imm = 0x9C4
jb 0x9b10
addq $-0x9c4, %rdx           # imm = 0xF63C
movq %rdx, 0x8080(%rbx)
movq %rcx, 0x38(%rax)
jmp 0x9b12
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6d42
movq %rax, %rbx
movq 0x204cf26(%rip), %rax   # 0x2056a80
cmpq %rax, 0x60(%rbx)
je 0x9b8b
movq 0x8080(%r14), %rcx
subq %r15, %rcx
jae 0x9b70
xorl %ebx, %ebx
jmp 0x9b8b
movq %rcx, 0x8080(%r14)
movq %rax, 0x60(%rbx)
leaq 0x40(%rbx), %rdi
movq %rbx, %rsi
addq $0x20, %rsi
callq 0x9ee4
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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(%rbx), %rdi
testq %rdi, %rdi
je 0x9bb9
movq %r14, %rsi
callq 0xa648
testb %al, %al
jne 0x9bd3
movq 0x48(%rbx), %rbx
jmp 0x9b9e
pushq $0x1
popq %rdi
pushq $0x50
popq %rsi
callq 0x31b0
movq %rax, 0x48(%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x9ee4
movq 0x48(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9c7a
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rsi), %rsi
callq 0x9bdf
movq (%r14), %r15
testq %r15, %r15
je 0x9c1c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x68de
testl %eax, %eax
jne 0x9c26
addq $0x28, %r15
movq %r15, %r14
jmp 0x9bfc
andq $0x0, 0x28(%rbx)
movq %rbx, (%r14)
jmp 0x9c75
leaq 0x20(%rbx), %rcx
movq %rcx, %rax
movq (%rcx), %rdx
leaq 0x68(%rdx), %rcx
testq %rdx, %rdx
jne 0x9c2a
movq 0x20(%r15), %rcx
movq %rcx, (%rax)
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 0x9c52
movq (%r14), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, (%rax)
movq (%rbx), %rax
movq (%r14), %rcx
movq %rax, 0x18(%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/src/evm.c
// Function: memoryGasCost
static uint64_t memoryGasCost(uint64_t capacity) {
    if (capacity > OVERFLOW_WORDS) {
        // this maximum value should be large enough to signal out of gas
        return 0xffffffffffffffffull;
    }
    uint64_t words = (capacity + 31) >> 5;
    return words * G_MEM + words * words / G_QUADDIV;
}

// Assembly:
movabsq $0x2d413cc6fe0, %rcx    # imm = 0x2D413CC6FE0
cmpq %rcx, %rdi
jbe 0x9c8e
pushq $-0x1
popq %rax
retq
movq %rdi, %rax
addq $0x1f, %rax
shrq $0x5, %rax
leaq (%rax,%rax,2), %rcx
imulq %rax, %rax
shrq $0x9, %rax
addq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9d10
movq %rdi, %r14
callq 0x6d42
movq %rax, %r15
leaq 0x20(%rax), %r12
movq (%rbx), %rsi
addq $0x40, %rsi
movq %r12, %rdi
callq 0xa648
testb %al, %al
je 0x9d1c
movq (%rbx), %rsi
addq $0x20, %rsi
movq %r12, %rdi
callq 0x9ee4
movq (%rbx), %rsi
movq 0x60(%rsi), %rax
movq %rax, 0x60(%r15)
addq $0x68, %rsi
movq %r14, %rdi
callq 0x9ca9
movq (%rbx), %rdi
callq 0x3040
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x5f00(%rip), %rdi      # 0xfc23
leaq 0x5ea9(%rip), %rsi      # 0xfbd3
leaq 0x5f20(%rip), %rcx      # 0xfc51
movl $0x611, %edx            # imm = 0x611
callq 0x3120
// File: /workspace/github_c_makefile_star2_O2/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 0x9d5c
addq $0x20, %rdi
callq 0x9d3b
movq (%rbx), %rdi
callq 0x3040
andq $0x0, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/src/keccak.c
// Function: hash
static inline int hash(uint8_t* out, size_t outlen,
                       const uint8_t* in, size_t inlen,
                       size_t rate, uint8_t delim) {
  if ((out == NULL) || ((in == NULL) && inlen != 0) || (rate >= Plen)) {
    return -1;
  }
  uint8_t a[Plen] = {0};
  // Absorb input.
  foldP(in, inlen, xorin);
  // Xor in the DS and pad frame.
  a[inlen] ^= delim;
  a[rate - 1] ^= 0x80;
  // Xor in the last block.
  xorin(a, in, inlen);
  // Apply P
  P(a);
  // Squeeze output.
  foldP(out, outlen, setout);
  setout(a, out, outlen);
  memset(a, 0, 200);
  return 0;
}

// Assembly:
pushq $-0x1
popq %rax
testq %rdi, %rdi
je 0xbbf2
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %r15
movq %rdx, %r12
testq %rdx, %rdx
sete %cl
testq %r15, %r15
setne %dl
testb %dl, %cl
jne 0xbbe1
movl %r8d, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r13
movl $0xc8, %edx
movq %r13, %rdi
xorl %esi, %esi
callq 0x3140
cmpq $0x88, %r15
jb 0xbba7
movl $0x88, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0xbc06
movq %r13, %rdi
callq 0xbc19
addq $0x88, %r12
addq $-0x88, %r15
jmp 0xbb76
xorb %bpl, (%rsp,%r15)
movq %rsp, %r13
xorb $-0x80, 0x87(%r13)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xbc06
movq %r13, %rdi
callq 0xbc19
xorl %eax, %eax
cmpq %rax, %rbx
je 0xbbdf
movb (%rsp,%rax), %cl
movb %cl, (%r14,%rax)
incq %rax
jmp 0xbbce
xorl %eax, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/src/scan.c
// Function: scanInit
void scanInit() {
    programCounter = (uint32_t)-1;
    inDataSection = false;
    lineNumber = 1;
    labelQueueInit();
}

// Assembly:
orl $-0x1, 0x204a19d(%rip)  # 0x2056e20
andq $0x0, 0x204a1a5(%rip)   # 0x2056e30
movb $0x0, 0x204a192(%rip)   # 0x2056e24
movl $0x1, 0x204a18c(%rip)   # 0x2056e28
leaq 0x204a18d(%rip), %rax   # 0x2056e30
movq %rax, 0x204f996(%rip)   # 0x205c640
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpw $0x7830, %cx            # imm = 0x7830
jne 0xcebb
addq $0x2, %rax
movq %rax, (%rdi)
jmp 0xced6
incq %rax
xorl %esi, %esi
cmpb $0x2d, %cl
jne 0xccbc
movq %rax, (%rdi)
xorl $0x1, %esi
movb (%rax), %cl
incq %rax
jmp 0xcec0
// File: /workspace/github_c_makefile_star2_O2/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), %r14
movq %r14, %r15
movb (%r15), %al
leal -0x3a(%rax), %ecx
cmpb $-0xb, %cl
ja 0xcefa
andb $-0x21, %al
addb $-0x47, %al
cmpb $-0x7, %al
jbe 0xcf02
incq %r15
movq %r15, (%rdi)
jmp 0xcee7
movb $0x5f, %bl
leaq 0x204f745(%rip), %r12   # 0x205c650
movq %r15, %rax
subq %r14, %rax
jbe 0xcf64
cmpq $0x2, %rax
jl 0xcf3f
leaq -0x2(%r15), %r13
movzbl -0x2(%r15), %edi
callq 0xd765
movl %eax, %ebp
shlb $0x4, %bpl
movzbl -0x1(%r15), %edi
callq 0xd765
addb %bpl, %al
movq %r13, %r15
jmp 0xcf4c
movzbl -0x1(%r15), %edi
decq %r15
callq 0xd765
movzbl 0x2049ed9(%rip), %ecx   # 0x2056e2c
movb %al, (%rcx,%r12)
leal 0x1(%rcx), %eax
movb %al, 0x2049ecc(%rip)    # 0x2056e2c
incb %bl
jmp 0xcf0b
leal -0x5f(%rbx), %eax
cmpb $0x21, %al
jb 0xcf74
cmpb $0x0, 0x2049eb2(%rip)   # 0x2056e24
je 0xcf85
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4256(%rip), %rdi      # 0x111e2
leaq 0x426c(%rip), %rsi      # 0x111ff
leaq 0x4270(%rip), %rcx      # 0x1120a
pushq $0x42
popq %rdx
callq 0x3120
// File: /workspace/github_c_makefile_star2_O2/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 0x2049e71(%rip), %eax   # 0x2056e20
incl %eax
movl %eax, 0x2049e69(%rip)   # 0x2056e20
movl %eax, 0x28(%rsp)
movb 0x2049e6b(%rip), %al    # 0x2056e2c
testb %al, %al
jne 0xcfd0
callq 0xd11d
movb 0x2049e5c(%rip), %al    # 0x2056e2c
movzbl %al, %ebx
leaq 0x204fa76(%rip), %r14   # 0x205ca50
movq (%r14,%rbx,8), %rdi
testq %rdi, %rdi
je 0xd04a
movups (%rdi), %xmm0
movups %xmm0, 0x38(%rsp)
callq 0x3040
andq $0x0, (%r14,%rbx,8)
leal -0x1(%rbx), %eax
movb %al, 0x2049e2e(%rip)    # 0x2056e2c
movzbl %al, %eax
leaq 0x204f648(%rip), %r14   # 0x205c650
movzbl (%rax,%r14), %ebx
cmpl $0x38, %ebx
je 0xd098
cmpl $0x39, %ebx
je 0xd064
cmpl $0x5b, %ebx
jne 0xd0d8
movw $0x1, 0x2c(%rsp)
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0xd385
movb $0x5b, %bl
jmp 0xd113
decb %bl
movb %bl, 0x2049dda(%rip)    # 0x2056e2c
movzbl %bl, %eax
leaq 0x204f5f4(%rip), %rcx   # 0x205c650
movb (%rax,%rcx), %bl
jmp 0xd113
movw %ax, 0x2c(%rsp)
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0xd385
movb 0x2049da5(%rip), %al    # 0x2056e2c
decb %al
movb %al, 0x2049d9d(%rip)    # 0x2056e2c
movzbl %al, %eax
movb (%rax,%r14), %bl
jmp 0xd113
movb $0x1, 0x2e(%rsp)
pushq $0x30
popq %rdi
callq 0x3200
movq 0x204f594(%rip), %rcx   # 0x205c640
movq %rax, (%rcx)
andq $0x0, 0x28(%rax)
leaq 0x28(%rax), %rcx
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movb $0x38, 0x20(%rax)
movq %rcx, 0x204f56c(%rip)   # 0x205c640
movb $0x38, %bl
jmp 0xd113
movb $0x1, 0x2e(%rsp)
pushq $0x30
popq %rdi
callq 0x3200
movq 0x204f554(%rip), %rcx   # 0x205c640
movq %rax, (%rcx)
andq $0x0, 0x28(%rax)
leaq 0x28(%rax), %rcx
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movb %bl, 0x20(%rax)
movq %rcx, 0x204f52d(%rip)   # 0x205c640
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x7b
popq %rdi
movq %rbx, %rsi
callq 0x3180
pushq $0x22
popq %r15
leaq 0x3b40(%rip), %r12      # 0x111d7
xorl %r13d, %r13d
movl 0x2049798(%rip), %eax   # 0x2056e38
cmpq %rax, %r13
jae 0xd732
testq %r13, %r13
je 0xd6b9
pushq $0x2c
popq %rdi
movq %rbx, %rsi
callq 0x3180
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x3180
pushq $0x9
popq %rdi
movq %rbx, %rsi
callq 0x3180
movl %r15d, %edi
movq %rbx, %rsi
callq 0x3180
movq %r13, %r14
shlq $0x4, %r14
leaq 0x2049758(%rip), %rax   # 0x2056e40
addq %rax, %r14
xorl %ebp, %ebp
cmpq 0x8(%r14), %rbp
jae 0xd707
movq (%r14), %rax
movsbl (%rax,%rbp), %edi
movq %rbx, %rsi
callq 0x3180
incq %rbp
jmp 0xd6ed
movl %r15d, %edi
movq %rbx, %rsi
callq 0x3180
leaq 0x204df27(%rip), %rax   # 0x205b640
movl (%rax,%r13,4), %edx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x31d0
incq %r13
jmp 0xd69a
testl %eax, %eax
je 0xd741
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x3180
pushq $0x7d
popq %rdi
movq %rbx, %rsi
callq 0x3180
pushq $0xa
popq %rdi
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_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movl 0x204966e(%rip), %r15d  # 0x2056e28
movsbl (%r14), %ebp
movl %ebp, %edi
callq 0xdaca
testl %ebp, %ebp
je 0xd7df
testl %eax, %eax
je 0xd7df
cmpb $0xa, %bpl
jne 0xd806
incl %r15d
movl %r15d, 0x204964b(%rip)  # 0x2056e28
jmp 0xd806
cmpb $0x2f, %bpl
jne 0xd80e
incq %r14
movb $0x2f, %al
cmpb $0xa, %al
je 0xd7f9
movq %r14, (%rbx)
movb (%r14), %al
incq %r14
jmp 0xd7ea
incl %r15d
movl %r15d, 0x2049625(%rip)  # 0x2056e28
decq %r14
incq %r14
movq %r14, (%rbx)
jmp 0xd7ba
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
xorl %r14d, %r14d
movb (%r15,%r14), %al
addb $-0x7b, %al
cmpb $-0x1b, %al
jbe 0xd842
leaq (%r15,%r14), %rax
incq %rax
movq %rax, (%rbx)
incq %r14
jmp 0xd829
movq %rbx, %rdi
callq 0xd7a6
cmpb $0x3a, %al
jne 0xd861
incq (%rbx)
pushq $0x5b
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xdb12
jmp 0xd889
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xdb12
movzbl 0x20495b7(%rip), %eax   # 0x2056e2c
leal 0x1(%rax), %ecx
movb %cl, 0x20495ae(%rip)    # 0x2056e2c
leaq 0x204edcb(%rip), %rcx   # 0x205c650
movb $0x60, (%rax,%rcx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xd7a6
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/src/scan.c
// Function: scanDataSection
static void scanDataSection(const char **iter) {
    (*iter)++; // '{' or ','
    inDataSection = true;
    scanWaste(iter);

    const char *start = *iter;
    if (!isLowerCase(*start)) {
        fprintf(stderr, "Data section keys should be lowercase; instead found unexpected character %c at line %u\n", *start, lineNumber);
        exit(1);
    }
    for (char ch; isLowerCase(**iter); (*iter)++);
    const char *end = *iter;
    char next = scanWaste(iter);
    if (next != ':') {
        fprintf(stderr, "Data section expects colon after key; instead found unexpected character %c at line %u\n", next, lineNumber);
        exit(1);
    }
    (*iter)++;
    scanWaste(iter);
    if (**iter == '"') {
        // TODO parse ascii
    } else if (isHexConstantPrefix(*iter)) {
        *iter += 2;
        parseHex(iter);
    }
    scanstackPushLabel(start, end - start, CODECOPY);
    scanWaste(iter);
    if (**iter == '}') {
        inDataSection = false;
        (*iter)++;
        scanWaste(iter);
    } else if (**iter != ',') {
        fprintf(stderr, "Data section expecting ',' or '}'; instead found unexpected character %c at line %u\n", **iter, lineNumber);
        exit(1);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
incq (%rdi)
movb $0x1, 0x204957c(%rip)   # 0x2056e24
callq 0xd7a6
movq (%rbx), %r14
movb (%r14), %al
leal -0x7b(%rax), %ecx
cmpb $-0x1a, %cl
jb 0xd95b
pushq $0x1
popq %r15
addb $-0x7b, %al
cmpb $-0x1b, %al
jbe 0xd8d9
leaq (%r14,%r15), %rax
movq %rax, (%rbx)
movb (%r14,%r15), %al
incq %r15
jmp 0xd8c3
movq %rbx, %rdi
callq 0xd7a6
cmpb $0x3a, %al
jne 0xd977
incq (%rbx)
movq %rbx, %rdi
callq 0xd7a6
movq (%rbx), %rax
cmpb $0x22, (%rax)
je 0xd912
cmpw $0x7830, (%rax)         # imm = 0x7830
jne 0xd912
addq $0x2, %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0xced6
decq %r15
pushq $0x39
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0xdb12
movq %rbx, %rdi
callq 0xd7a6
movq (%rbx), %rax
movzbl (%rax), %ecx
cmpl $0x2c, %ecx
je 0xd955
cmpl $0x7d, %ecx
jne 0xd993
movb $0x0, 0x20494e2(%rip)   # 0x2056e24
incq %rax
movq %rax, (%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xd7a6
popq %rbx
popq %r14
popq %r15
retq
movsbl %al, %edx
movq 0x8693(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
movl 0x20494ba(%rip), %ecx   # 0x2056e28
leaq 0x392e(%rip), %rsi      # 0x112a3
jmp 0xd9ad
movsbl %al, %edx
movq 0x8677(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
movl 0x204949e(%rip), %ecx   # 0x2056e28
leaq 0x396b(%rip), %rsi      # 0x112fc
jmp 0xd9ad
movsbl %cl, %edx
movq 0x865b(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
movl 0x2049482(%rip), %ecx   # 0x2056e28
leaq 0x39a7(%rip), %rsi      # 0x11354
xorl %eax, %eax
callq 0x31d0
pushq $0x1
popq %rdi
callq 0x3280