LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, -0x50(%rbp)
leaq 0x10(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq %r8, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x10(%rsp)
callq 0x8ac0
movq %rax, -0x28(%rbp)
movq 0x2056f05(%rip), %rcx   # 0x2060a70
movq -0x28(%rbp), %rax
movq %rcx, 0x38(%rax)
movq 0x2056f08(%rip), %rax   # 0x2060a82
movq %rax, -0x48(%rbp)
movq 0x2056f05(%rip), %rax   # 0x2060a8a
movq %rax, -0x40(%rbp)
movl 0x2056f03(%rip), %eax   # 0x2060a92
movl %eax, -0x38(%rbp)
leaq -0x48(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x10(%rsp)
callq 0x8ac0
movq -0x58(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq 0x2056eaf(%rip), %rcx   # 0x2060a70
movq -0x30(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %r8
movq -0x8(%rbp), %r9
callq 0x98c0
movq -0x50(%rbp), %rax
movq 0x2056e83(%rip), %rcx   # 0x2060a70
addq $0x1, %rcx
movq %rcx, 0x2056e78(%rip)   # 0x2060a70
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/include/address.h
// Function: AddressIsPrecompile
static inline int AddressIsPrecompile(const address_t address) {
    return !address.address[0] &&
        !address.address[1] &&
        !address.address[2] &&
        !address.address[3] &&
        !address.address[4] &&
        !address.address[5] &&
        !address.address[6] &&
        !address.address[7] &&
        !address.address[8] &&
        !address.address[9] &&
        !address.address[10] &&
        !address.address[11] &&
        !address.address[12] &&
        !address.address[13] &&
        !address.address[14] &&
        !address.address[15] &&
        !address.address[16] &&
        !address.address[17];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rcx
movq %rcx, -0x10(%rbp)
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x1(%rbp)
jne 0x9e2a
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, 0x1(%rcx)
movb %al, -0x1(%rbp)
jne 0x9e2a
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, 0x2(%rcx)
movb %al, -0x1(%rbp)
jne 0x9e2a
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, 0x3(%rcx)
movb %al, -0x1(%rbp)
jne 0x9e2a
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, 0x4(%rcx)
movb %al, -0x1(%rbp)
jne 0x9e2a
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, 0x5(%rcx)
movb %al, -0x1(%rbp)
jne 0x9e2a
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, 0x6(%rcx)
movb %al, -0x1(%rbp)
jne 0x9e2a
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, 0x7(%rcx)
movb %al, -0x1(%rbp)
jne 0x9e2a
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, 0x8(%rcx)
movb %al, -0x1(%rbp)
jne 0x9e2a
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, 0x9(%rcx)
movb %al, -0x1(%rbp)
jne 0x9e2a
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, 0xa(%rcx)
movb %al, -0x1(%rbp)
jne 0x9e2a
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, 0xb(%rcx)
movb %al, -0x1(%rbp)
jne 0x9e2a
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, 0xc(%rcx)
movb %al, -0x1(%rbp)
jne 0x9e2a
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, 0xd(%rcx)
movb %al, -0x1(%rbp)
jne 0x9e2a
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, 0xe(%rcx)
movb %al, -0x1(%rbp)
jne 0x9e2a
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, 0xf(%rcx)
movb %al, -0x1(%rbp)
jne 0x9e2a
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, 0x10(%rcx)
movb %al, -0x1(%rbp)
jne 0x9e2a
movq -0x10(%rbp), %rax
cmpb $0x0, 0x11(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movb $0x3, -0x15(%rbp)
movb -0x15(%rbp), %al
movb %al, %cl
addb $-0x1, %cl
movb %cl, -0x15(%rbp)
movzbl %al, %eax
cmpl $0x0, %eax
jle 0x9ed6
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movzbl -0x15(%rbp), %edx
addl (%rcx,%rdx,4), %eax
movq -0x10(%rbp), %rcx
movzbl -0x15(%rbp), %edx
addl (%rcx,%rdx,4), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movzbl -0x15(%rbp), %edx
cmpl (%rcx,%rdx,4), %eax
jae 0x9ebf
movl $0x1, -0x14(%rbp)
jmp 0x9ec6
movl $0x0, -0x14(%rbp)
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movzbl -0x15(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
jmp 0x9e77
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8000(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8048(%rax)
movq -0x8(%rbp), %rdi
addq $0x8058, %rdi           # imm = 0x8058
xorl %eax, %eax
movl %eax, %esi
callq 0xa230
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8080(%rax), %rax
movq %rax, -0x10(%rbp)
movq 0x2042b10(%rip), %rax   # 0x204ca50
addq $0x8090, %rax           # imm = 0x8090
movq %rax, 0x2042b03(%rip)   # 0x204ca50
movq -0x8(%rbp), %rsi
callq 0xa280
movq -0x18(%rbp), %rdi
movq 0x2042aef(%rip), %rax   # 0x204ca50
addq $-0x8090, %rax          # imm = 0xFFFF7F70
movq %rax, 0x2042ae2(%rip)   # 0x204ca50
movq -0x8(%rbp), %rax
movq 0x8080(%rax), %rax
movq %rax, 0x30(%rdi)
movq 0x2042ad4(%rip), %rax   # 0x204ca58
andq $0x20, %rax
cmpq $0x0, %rax
je 0xa01d
movq 0x1605f(%rip), %rax     # 0x1fff8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8790
movq -0x28(%rbp), %rdi
leaq 0x10bba(%rip), %rsi     # 0x1ab6e
movzwl %ax, %edx
callq 0x87c0
movq 0x16035(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
subq 0x8080(%rax), %rdx
leaq 0x10b94(%rip), %rsi     # 0x1ab70
movb $0x0, %al
callq 0x31e0
cmpq $0x23c34600, -0x10(%rbp) # imm = 0x23C34600
jae 0xa009
movq 0x16004(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x10b7b(%rip), %rsi     # 0x1ab7d
movb $0x0, %al
callq 0x31e0
movq 0x15fe8(%rip), %rax     # 0x1fff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x3180
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0xf7b0
testb $0x1, %al
jne 0xa030
jmp 0xa03d
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0xa1a0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/include/address.h
// Function: AddressToUint256
static inline void AddressToUint256(uint256_t *dst, address_t *src) {
    UPPER(UPPER_P(dst)) = 0;
    LOWER(UPPER_P(dst)) =
        ( ((uint64_t)src->address[0] << 24ull)
        | ((uint64_t)src->address[1] << 16ull)
        | ((uint64_t)src->address[2] << 8ull)
        | ((uint64_t)src->address[3])
    );
    UPPER(LOWER_P(dst)) =
        ( ((uint64_t)src->address[4] << 56ull)
        | ((uint64_t)src->address[5] << 48ull)
        | ((uint64_t)src->address[6] << 40ull)
        | ((uint64_t)src->address[7] << 32ull)
        | ((uint64_t)src->address[8] << 24ull)
        | ((uint64_t)src->address[9] << 16ull)
        | ((uint64_t)src->address[10] << 8ull)
        | ((uint64_t)src->address[11])
    );
    LOWER(LOWER_P(dst)) =
        ( ((uint64_t)src->address[12] << 56ull)
        | ((uint64_t)src->address[13] << 48ull)
        | ((uint64_t)src->address[14] << 40ull)
        | ((uint64_t)src->address[15] << 32ull)
        | ((uint64_t)src->address[16] << 24ull)
        | ((uint64_t)src->address[17] << 16ull)
        | ((uint64_t)src->address[18] << 8ull)
        | ((uint64_t)src->address[19])
    );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
shlq $0x18, %rcx
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
shlq $0x10, %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
shlq $0x8, %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
orq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
movl %eax, %ecx
shlq $0x38, %rcx
movq -0x10(%rbp), %rax
movzbl 0x5(%rax), %eax
shlq $0x30, %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movzbl 0x6(%rax), %eax
shlq $0x28, %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movzbl 0x7(%rax), %eax
shlq $0x20, %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movzbl 0x8(%rax), %eax
shlq $0x18, %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movzbl 0x9(%rax), %eax
shlq $0x10, %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movzbl 0xa(%rax), %eax
shlq $0x8, %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movzbl 0xb(%rax), %eax
orq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movzbl 0xc(%rax), %eax
movl %eax, %ecx
shlq $0x38, %rcx
movq -0x10(%rbp), %rax
movzbl 0xd(%rax), %eax
shlq $0x30, %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movzbl 0xe(%rax), %eax
shlq $0x28, %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movzbl 0xf(%rax), %eax
shlq $0x20, %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
shlq $0x18, %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movzbl 0x11(%rax), %eax
shlq $0x10, %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movzbl 0x12(%rax), %eax
shlq $0x8, %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movzbl 0x13(%rax), %eax
orq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xa1b8
jmp 0xa22a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x10(%rsp)
callq 0x8ac0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
addq $0x20, %rsi
callq 0xf210
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
callq 0xf2e0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x28, %rdi
callq 0xa1a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3040
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/include/address.h
// Function: AddressToPrecompile
static inline precompile_t AddressToPrecompile(const address_t address) {
    precompile_t precompile = address.address[18];
    precompile <<= 8;
    precompile |= address.address[19];
    return precompile;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movzbl 0x12(%rax), %ecx
movl %ecx, -0x4(%rbp)
movl -0x4(%rbp), %ecx
shll $0x8, %ecx
movl %ecx, -0x4(%rbp)
movzbl 0x13(%rax), %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/evm.c
// Function: dumpStack
static inline void dumpStack(context_t *context) {
    uint256_t *pos = context->top;
    char buf[67];
    while (--pos >= context->bottom) {
        tostring256(pos, 16, buf, 67);
        fprintf(stderr, "%lu: %s\n", pos - context->bottom, buf);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8000(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $-0x20, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jb 0xe854
movq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rdx
movl $0x10, %esi
movl $0x43, %ecx
callq 0x124e0
movq 0x117ca(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
subq %rax, %rdx
sarq $0x5, %rdx
leaq -0x60(%rbp), %rcx
leaq 0xc4dc(%rip), %rsi      # 0x1ad27
movb $0x0, %al
callq 0x31e0
jmp 0xe7fb
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/evm.c
// Function: dumpMemory
static inline void dumpMemory(memory_t *memory) {
    for (uint32_t i = 0; i < memory->num_uint8s; i++) {
        fprintf(stderr, "%02x", memory->uint8s[i]);
        if (i % 32 == 31) {
            fputc('\n', stderr);
        }
    }
    if (memory->num_uint8s % 32 == 0) {
        return;
    }
    for (uint32_t i = 32 - memory->num_uint8s % 32; i --> 0;) {
        fputs("00", stderr);
    }
    fputc('\n', stderr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0xe8d2
movq 0x11772(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movzbl (%rax,%rcx), %edx
leaq 0xbb6f(%rip), %rsi      # 0x1a40e
movb $0x0, %al
callq 0x31e0
movl -0xc(%rbp), %eax
andl $0x1f, %eax
cmpl $0x1f, %eax
jne 0xe8c5
movq 0x11740(%rip), %rax     # 0x1fff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x3180
jmp 0xe8c7
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xe873
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x1f, %rax
cmpq $0x0, %rax
jne 0xe8e5
jmp 0xe937
movq -0x8(%rbp), %rax
movq (%rax), %rcx
andq $0x1f, %rcx
movl $0x20, %eax
subq %rcx, %rax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x10(%rbp)
cmpl $0x0, %eax
jbe 0xe923
movq 0x116e6(%rip), %rax     # 0x1fff8
movq (%rax), %rsi
leaq 0xc414(%rip), %rdi      # 0x1ad30
callq 0x3130
jmp 0xe8fb
movq 0x116ce(%rip), %rax     # 0x1fff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x3180
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x8058, %rax           # imm = 0x8058
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0xe9da
movq -0x18(%rbp), %rdi
callq 0xf130
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0xf130
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8080(%rcx), %rax
jbe 0xe9a9
movb $0x0, -0x1(%rbp)
jmp 0xe9de
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8080(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8080(%rax)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf190
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x10(%rsp)
callq 0x8ac0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
cmpq 0x2052041(%rip), %rax   # 0x2060a70
je 0xea7c
movq $0x9c4, -0x20(%rbp)     # imm = 0x9C4
movq -0x10(%rbp), %rax
movq 0x8080(%rax), %rax
cmpq -0x20(%rbp), %rax
jae 0xea54
movq $0x0, -0x8(%rbp)
jmp 0xea84
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8080(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8080(%rax)
movq 0x2051ffc(%rip), %rcx   # 0x2060a70
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/include/address.h
// Function: AddressFromUint256
static inline address_t AddressFromUint256(uint256_t *from) {
    address_t address;
    uint64_t scratch = LOWER(UPPER_P(from));
    address.address[0] = scratch >> 24;
    address.address[1] = scratch >> 16;
    address.address[2] = scratch >> 8;
    address.address[3] = scratch;

    scratch = UPPER(LOWER_P(from));
    address.address[4] = scratch >> 56;
    address.address[5] = scratch >> 48;
    address.address[6] = scratch >> 40;
    address.address[7] = scratch >> 32;
    address.address[8] = scratch >> 24;
    address.address[9] = scratch >> 16;
    address.address[10] = scratch >> 8;
    address.address[11] = scratch;

    scratch = LOWER(LOWER_P(from));
    address.address[12] = scratch >> 56;
    address.address[13] = scratch >> 48;
    address.address[14] = scratch >> 40;
    address.address[15] = scratch >> 32;
    address.address[16] = scratch >> 24;
    address.address[17] = scratch >> 16;
    address.address[18] = scratch >> 8;
    address.address[19] = scratch;

    return address;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
shrq $0x18, %rcx
movb %cl, (%rdi)
movq -0x10(%rbp), %rcx
shrq $0x10, %rcx
movb %cl, 0x1(%rdi)
movq -0x10(%rbp), %rcx
shrq $0x8, %rcx
movb %cl, 0x2(%rdi)
movq -0x10(%rbp), %rcx
movb %cl, 0x3(%rdi)
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
shrq $0x38, %rcx
movb %cl, 0x4(%rdi)
movq -0x10(%rbp), %rcx
shrq $0x30, %rcx
movb %cl, 0x5(%rdi)
movq -0x10(%rbp), %rcx
shrq $0x28, %rcx
movb %cl, 0x6(%rdi)
movq -0x10(%rbp), %rcx
shrq $0x20, %rcx
movb %cl, 0x7(%rdi)
movq -0x10(%rbp), %rcx
shrq $0x18, %rcx
movb %cl, 0x8(%rdi)
movq -0x10(%rbp), %rcx
shrq $0x10, %rcx
movb %cl, 0x9(%rdi)
movq -0x10(%rbp), %rcx
shrq $0x8, %rcx
movb %cl, 0xa(%rdi)
movq -0x10(%rbp), %rcx
movb %cl, 0xb(%rdi)
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
shrq $0x38, %rcx
movb %cl, 0xc(%rdi)
movq -0x10(%rbp), %rcx
shrq $0x30, %rcx
movb %cl, 0xd(%rdi)
movq -0x10(%rbp), %rcx
shrq $0x28, %rcx
movb %cl, 0xe(%rdi)
movq -0x10(%rbp), %rcx
shrq $0x20, %rcx
movb %cl, 0xf(%rdi)
movq -0x10(%rbp), %rcx
shrq $0x18, %rcx
movb %cl, 0x10(%rdi)
movq -0x10(%rbp), %rcx
shrq $0x10, %rcx
movb %cl, 0x11(%rdi)
movq -0x10(%rbp), %rcx
shrq $0x8, %rcx
movb %cl, 0x12(%rdi)
movq -0x10(%rbp), %rcx
movb %cl, 0x13(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8008(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8ef0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x60(%rax), %rax
cmpq 0x2051e9d(%rip), %rax   # 0x2060a70
je 0xec2d
movq -0x10(%rbp), %rax
movq 0x8080(%rax), %rax
cmpq -0x20(%rbp), %rax
jae 0xebf0
movq $0x0, -0x8(%rbp)
jmp 0xec35
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8080(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8080(%rax)
movq 0x2051e60(%rip), %rcx   # 0x2060a70
movq -0x30(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
movq -0x30(%rbp), %rsi
addq $0x20, %rsi
callq 0xf820
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0xec9a
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x10410
testb $0x1, %al
jne 0xec7c
jmp 0xec89
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xecce
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq $0x48, %rax
movq %rax, -0x20(%rbp)
jmp 0xec5c
movl $0x1, %edi
movl $0x50, %esi
callq 0x31c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xf820
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xed7c
jmp 0xee7c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0xed60
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xee62
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x8730
cmpl $0x0, %eax
je 0xee4e
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0xeddb
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x68, %rax
movq %rax, -0x18(%rbp)
jmp 0xedc0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0xee27
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
jmp 0xee0c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0xee7c
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x28, %rax
movq %rax, -0x8(%rbp)
jmp 0xed8d
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/evm.c
// Function: evmDelegateCall
static result_t evmDelegateCall(uint64_t gas, account_t *codeSource, data_t input) {
    context_t *parent = callstack.next - 1;
    context_t *callContext = callstack.next;

    callContext->gas = gas;
    callContext->readonly = parent->readonly;
    BalanceCopy(callContext->callValue, parent->callValue);
    AddressCopy(callContext->caller, parent->caller);
    callContext->account = parent->account;
    callContext->code = codeSource->code;
    callContext->callData = input;
    return _evmCall(callContext);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rcx, -0x10(%rbp)
movq %r8, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq 0x203db9a(%rip), %rax   # 0x204ca50
addq $-0x8090, %rax          # imm = 0xFFFF7F70
movq %rax, -0x28(%rbp)
movq 0x203db89(%rip), %rax   # 0x204ca50
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8080(%rax)
movq -0x28(%rbp), %rax
movb 0x8088(%rax), %cl
movq -0x30(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x8088(%rax)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x8038(%rcx), %rdx
movq %rdx, 0x8038(%rax)
movl 0x8040(%rcx), %ecx
movl %ecx, 0x8040(%rax)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x8010(%rcx), %rdx
movq %rdx, 0x8010(%rax)
movq 0x8018(%rcx), %rdx
movq %rdx, 0x8018(%rax)
movl 0x8020(%rcx), %ecx
movl %ecx, 0x8020(%rax)
movq -0x28(%rbp), %rax
movq 0x8008(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8008(%rax)
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x20(%rcx), %rdx
movq %rdx, 0x8028(%rax)
movq 0x28(%rcx), %rcx
movq %rcx, 0x8030(%rax)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8070(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x8078(%rax)
movq -0x30(%rbp), %rsi
callq 0x9ee0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/evm.c
// Function: evmStaticCall
static result_t evmStaticCall(address_t from, uint64_t gas, address_t to, data_t input) {
    context_t *callContext = callstack.next;
    callContext->gas = gas;

    callContext->readonly = true;
    callContext->callValue[0] = callContext->callValue[1] = callContext->callValue[2] = 0;
    AddressCopy(callContext->caller, from);
    callContext->account = getAccount(to);
    callContext->code = callContext->account->code;
    callContext->callData = input;

    return _evmCall(callContext);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x38(%rbp)
movq %rdi, %rax
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq %rax, -0x28(%rbp)
leaq 0x28(%rbp), %rax
leaq 0x10(%rbp), %rdx
movq %rdi, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq 0x203da6a(%rip), %rcx   # 0x204ca50
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq %rsi, 0x8080(%rcx)
movq -0x20(%rbp), %rcx
movb $0x1, 0x8088(%rcx)
movq -0x20(%rbp), %rcx
movl $0x0, 0x8040(%rcx)
movq -0x20(%rbp), %rcx
movl $0x0, 0x803c(%rcx)
movq -0x20(%rbp), %rcx
movl $0x0, 0x8038(%rcx)
movq -0x20(%rbp), %rcx
movq (%rdx), %rsi
movq %rsi, 0x8010(%rcx)
movq 0x8(%rdx), %rsi
movq %rsi, 0x8018(%rcx)
movl 0x10(%rdx), %edx
movl %edx, 0x8020(%rcx)
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x10(%rsp)
callq 0x8ac0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8008(%rax)
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x8008(%rcx), %rcx
movq 0x20(%rcx), %rdx
movq %rdx, 0x8028(%rax)
movq 0x28(%rcx), %rcx
movq %rcx, 0x8030(%rax)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8070(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x8078(%rax)
movq -0x20(%rbp), %rsi
callq 0x9ee0
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movabsq $0x2d413cc6fe0, %rax    # imm = 0x2D413CC6FE0
cmpq %rax, -0x10(%rbp)
jbe 0xf152
movq $-0x1, -0x8(%rbp)
jmp 0xf17b
movq -0x10(%rbp), %rax
addq $0x1f, %rax
shrq $0x5, %rax
movq %rax, -0x18(%rbp)
imulq $0x3, -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
imulq -0x18(%rbp), %rcx
shrq $0x9, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xf22f
jmp 0xf2d8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x8ef0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x40, %rsi
callq 0x10410
testb $0x1, %al
jne 0xf261
jmp 0xf263
jmp 0xf282
leaq 0xbac9(%rip), %rdi      # 0x1ad33
leaq 0xba72(%rip), %rsi      # 0x1ace3
movl $0x611, %edx            # imm = 0x611
leaq 0xbae4(%rip), %rcx      # 0x1ad61
callq 0x3120
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x20, %rsi
callq 0xf820
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x60(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x68, %rsi
callq 0xf210
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3040
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xf2f8
jmp 0xf31f
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
callq 0xf2e0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3040
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/evm.c
// Function: BalanceSub
static inline bool BalanceSub(val_t from, val_t amount) {
    uint32_t borrow = 0;
    uint8_t i = 3;
    val_t result;
    while (i --> 0) {
        result[i] = from[i] - amount[i] - borrow;
        if (result[i] > from[i]) {
            borrow = 1;
        } else {
            borrow = 0;
        }
    }
    if (borrow) {
        return false;
    }
    from[0] = result[0];
    from[1] = result[1];
    from[2] = result[2];
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movb $0x3, -0x1d(%rbp)
movb -0x1d(%rbp), %al
movb %al, %cl
addb $-0x1, %cl
movb %cl, -0x1d(%rbp)
movzbl %al, %eax
cmpl $0x0, %eax
jle 0xf3a2
movq -0x10(%rbp), %rax
movzbl -0x1d(%rbp), %ecx
movl (%rax,%rcx,4), %ecx
movq -0x18(%rbp), %rax
movzbl -0x1d(%rbp), %edx
subl (%rax,%rdx,4), %ecx
subl -0x1c(%rbp), %ecx
movzbl -0x1d(%rbp), %eax
movl %ecx, -0x2c(%rbp,%rax,4)
movzbl -0x1d(%rbp), %eax
movl -0x2c(%rbp,%rax,4), %eax
movq -0x10(%rbp), %rcx
movzbl -0x1d(%rbp), %edx
cmpl (%rcx,%rdx,4), %eax
jbe 0xf399
movl $0x1, -0x1c(%rbp)
jmp 0xf3a0
movl $0x0, -0x1c(%rbp)
jmp 0xf347
cmpl $0x0, -0x1c(%rbp)
je 0xf3ae
movb $0x0, -0x1(%rbp)
jmp 0xf3cf
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/precompiles.c
// Function: PrecompileIsSupported
int PrecompileIsSupported(precompile_t precompile) {
    switch (precompile) {
#define PRECOMPILE(name,address,supported) case name: return supported;
        PRECOMPILES
#undef PRECOMPILE
        default:
            return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0xa, %rax
ja 0xf46b
movq -0x10(%rbp), %rax
leaq 0xba01(%rip), %rcx      # 0x1ae00
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0xf472
movl $0x0, -0x4(%rbp)
jmp 0xf472
movl $0x0, -0x4(%rbp)
jmp 0xf472
movl $0x0, -0x4(%rbp)
jmp 0xf472
movl $0x1, -0x4(%rbp)
jmp 0xf472
movl $0x0, -0x4(%rbp)
jmp 0xf472
movl $0x0, -0x4(%rbp)
jmp 0xf472
movl $0x0, -0x4(%rbp)
jmp 0xf472
movl $0x0, -0x4(%rbp)
jmp 0xf472
movl $0x0, -0x4(%rbp)
jmp 0xf472
movl $0x0, -0x4(%rbp)
jmp 0xf472
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movb %r9b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movb %al, -0x31(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12684
cmpq $0x0, -0x20(%rbp)
jne 0x1267a
cmpq $0x0, -0x28(%rbp)
jne 0x12684
cmpq $0xc8, -0x30(%rbp)
jb 0x12690
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x127b5
leaq -0x100(%rbp), %rdi
xorl %esi, %esi
movl $0xc8, %edx
callq 0x3140
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jb 0x126ea
leaq -0x100(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x12830
leaq -0x100(%rbp), %rdi
callq 0x12890
movq -0x30(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x126a3
movzbl -0x31(%rbp), %edx
movq -0x28(%rbp), %rax
movzbl -0x100(%rbp,%rax), %ecx
xorl %edx, %ecx
movb %cl, -0x100(%rbp,%rax)
movq -0x30(%rbp), %rax
subq $0x1, %rax
movzbl -0x100(%rbp,%rax), %ecx
xorl $0x80, %ecx
movb %cl, -0x100(%rbp,%rax)
leaq -0x100(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x12830
leaq -0x100(%rbp), %rdi
callq 0x12890
movq -0x18(%rbp), %rax
cmpq -0x30(%rbp), %rax
jb 0x12787
leaq -0x100(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x15960
leaq -0x100(%rbp), %rdi
callq 0x12890
movq -0x30(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x12740
leaq -0x100(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x15960
leaq -0x100(%rbp), %rdi
xorl %esi, %esi
movl $0xc8, %edx
callq 0x3140
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/scan.c
// Function: scanInit
void scanInit() {
    programCounter = (uint32_t)-1;
    inDataSection = false;
    lineNumber = 1;
    labelQueueInit();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xffffffff, 0x204a142(%rip) # imm = 0xFFFFFFFF
movb $0x0, 0x204a13f(%rip)   # 0x2060e14
movl $0x1, 0x204a139(%rip)   # 0x2060e18
callq 0x180f0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x17290
cmpl $0x0, %eax
je 0x17249
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x172b0
movb %al, -0x1(%rbp)
jmp 0x17280
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x173a0
cmpl $0x0, %eax
je 0x17271
cmpl $0x0, -0x14(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
jmp 0x17250
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x16d30
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x18130
cmpl $0x0, %eax
je 0x172eb
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x172c7
movb $0x0, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jbe 0x1735e
movb -0x11(%rbp), %al
addb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0x2, %rax
jl 0x1733c
movq -0x20(%rbp), %rax
addq $-0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x181b0
movzbl %al, %edi
callq 0x171e0
jmp 0x1735c
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %edi
callq 0x181f0
movzbl %al, %edi
callq 0x171e0
jmp 0x172fa
movzbl -0x11(%rbp), %eax
cmpl $0x20, %eax
jle 0x17370
testb $0x1, 0x2049aa6(%rip)   # 0x2060e14
je 0x17372
jmp 0x17391
leaq 0x5043(%rip), %rdi      # 0x1c3bc
leaq 0x5059(%rip), %rsi      # 0x1c3d9
movl $0x42, %edx
leaq 0x5058(%rip), %rcx      # 0x1c3e4
callq 0x3120
movzbl -0x11(%rbp), %eax
addl $0x5f, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/scan.c
// Function: parseNegative
static int parseNegative(const char **iter) {
    if (**iter == '-') {
        (*iter)++;
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x173ce
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x173d5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl 0x2049a1e(%rip), %eax   # 0x2060e10
addl $0x1, %eax
movl %eax, 0x2049a15(%rip)   # 0x2060e10
movl 0x2049a0f(%rip), %eax   # 0x2060e10
movl %eax, -0x30(%rbp)
callq 0x18110
cmpl $0x0, %eax
je 0x17417
movq -0x10(%rbp), %rdi
callq 0x17560
leaq -0x30(%rbp), %rdi
addq $0x10, %rdi
callq 0x17820
cmpl $0x0, %eax
je 0x17545
callq 0x18940
movb %al, -0x31(%rbp)
movzbl -0x31(%rbp), %eax
cmpl $0x5b, %eax
jne 0x1747a
movw $0x1, -0x2c(%rbp)
leaq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x178c0
movb -0x31(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x1754d
movzbl -0x31(%rbp), %eax
cmpl $0x39, %eax
jne 0x174c6
movzbl 0x2049992(%rip), %eax   # 0x2060e1c
movw %ax, -0x2c(%rbp)
leaq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x178c0
callq 0x18940
movb %al, -0x1(%rbp)
jmp 0x1754d
movzbl -0x31(%rbp), %eax
cmpl $0x38, %eax
jne 0x1750a
movb $0x1, -0x2a(%rbp)
leaq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
movzbl -0x31(%rbp), %edi
callq 0x179f0
movb -0x31(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x1754d
movb $0x1, -0x2a(%rbp)
leaq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
movzbl -0x31(%rbp), %edi
callq 0x179f0
movb -0x31(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x1754d
callq 0x18940
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/include/scanstack.h
// Function: scanstackTopLabel
static inline int scanstackTopLabel(label_t *out) {
    if (labelstack[scanstackIndex]) {
        *out = *labelstack[scanstackIndex];
        free(labelstack[scanstackIndex]);
        labelstack[scanstackIndex] = 0;
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movzbl 0x20495e9(%rip), %eax   # 0x2060e1c
movl %eax, %ecx
leaq 0x204f204(%rip), %rax   # 0x2066a40
cmpq $0x0, (%rax,%rcx,8)
je 0x178a3
movq -0x10(%rbp), %rax
movzbl 0x20495ce(%rip), %ecx   # 0x2060e1c
movl %ecx, %edx
leaq 0x204f1e9(%rip), %rcx   # 0x2066a40
movq (%rcx,%rdx,8), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movzbl 0x20495ac(%rip), %eax   # 0x2060e1c
movl %eax, %ecx
leaq 0x204f1c7(%rip), %rax   # 0x2066a40
movq (%rax,%rcx,8), %rdi
callq 0x3040
movzbl 0x2049593(%rip), %eax   # 0x2060e1c
movl %eax, %ecx
leaq 0x204f1ae(%rip), %rax   # 0x2066a40
movq $0x0, (%rax,%rcx,8)
movl $0x1, -0x4(%rbp)
jmp 0x178aa
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/include/labelQueue.h
// Function: labelQueuePush
static inline void labelQueuePush(jump_t jump, op_t type) {
    node_t *next = malloc(sizeof(node_t));
    *tail = next;
    next->next = NULL;
    next->jump = jump;
    next->type = type;
    tail = &next->next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
leaq 0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movb %al, -0x1(%rbp)
movl $0x30, %edi
callq 0x3210
movq -0x18(%rbp), %rcx
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq 0x204ec0d(%rip), %rax   # 0x2066630
movq %rdx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movb -0x1(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq %rax, 0x204ebc3(%rip)   # 0x2066630
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/include/labelQueue.h
// Function: labelQueuePop
static inline jump_t labelQueuePop(op_t *type) {
    node_t *prev = head;
    jump_t jump = head->jump;
    *type = head->type;
    head = head->next;
    free(prev);
    return jump;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq 0x2048ef6(%rip), %rax   # 0x2060e20
movq %rax, -0x10(%rbp)
movq 0x2048eeb(%rip), %rax   # 0x2060e20
movq (%rax), %rcx
movq %rcx, (%rdi)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rdi)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rdi)
movq 0x2048ec6(%rip), %rax   # 0x2060e20
movb 0x20(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq 0x2048eb6(%rip), %rax   # 0x2060e20
movq 0x28(%rax), %rax
movq %rax, 0x2048eab(%rip)   # 0x2060e20
movq -0x10(%rbp), %rdi
callq 0x3040
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)