LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/uint256.c
// Function: dumpUint64BE
static void dumpUint64BE(uint64_t source, uint8_t *target) {
    target[0] = source >> 56;
    target[1] = source >> 48;
    target[2] = source >> 40;
    target[3] = source >> 32;
    target[4] = source >> 24;
    target[5] = source >> 16;
    target[6] = source >> 8;
    target[7] = source;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
shrq $0x38, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
shrq $0x30, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rax
shrq $0x28, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x8(%rbp), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x8(%rbp), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x8(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x8(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x6(%rax)
movq -0x8(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x7(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/uint256.c
// Function: shiftl128
void shiftl128(const uint128_t *number, uint32_t value, uint128_t *target) {
    if (value >= 128) {
        clear128(target);
    } else if (value == 64) {
        UPPER_P(target) = LOWER_P(number);
        LOWER_P(target) = 0;
    } else if (value == 0) {
        copy128(target, number);
    } else if (value < 64) {
        UPPER_P(target) =
            (UPPER_P(number) << value) + (LOWER_P(number) >> (64 - value));
        LOWER_P(target) = (LOWER_P(number) << value);
    } else if ((128 > value) && (value > 64)) {
        UPPER_P(target) = LOWER_P(number) << (value - 64);
        LOWER_P(target) = 0;
    } else {
        clear128(target);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x80, -0xc(%rbp)
jb 0x367a
movq -0x18(%rbp), %rdi
callq 0x35c0
jmp 0x3759
cmpl $0x40, -0xc(%rbp)
jne 0x36a0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x3757
cmpl $0x0, -0xc(%rbp)
jne 0x36b8
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3510
jmp 0x3755
cmpl $0x40, -0xc(%rbp)
jae 0x370d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
shlq %cl, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl $0x40, %ecx
subl -0xc(%rbp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq -0x20(%rbp), %rcx
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
shlq %cl, %rax
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3753
movl $0x80, %eax
cmpl -0xc(%rbp), %eax
jbe 0x3748
cmpl $0x40, -0xc(%rbp)
jbe 0x3748
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
subl $0x40, %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x3751
movq -0x18(%rbp), %rdi
callq 0x35c0
jmp 0x3753
jmp 0x3755
jmp 0x3757
jmp 0x3759
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/uint256.c
// Function: shiftl256
void shiftl256(const uint256_t *number, uint32_t value, uint256_t *target) {
    if (value >= 256) {
        clear256(target);
    } else if (value == 128) {
        copy128(&UPPER_P(target), &LOWER_P(number));
        clear128(&LOWER_P(target));
    } else if (value == 0) {
        copy256(target, number);
    } else if (value < 128) {
        uint128_t tmp1;
        uint128_t tmp2;
        uint256_t result;
        shiftl128(&UPPER_P(number), value, &tmp1);
        shiftr128(&LOWER_P(number), (128 - value), &tmp2);
        add128(&tmp1, &tmp2, &UPPER(result));
        shiftl128(&LOWER_P(number), value, &LOWER(result));
        copy256(target, &result);
    } else if ((256 > value) && (value > 128)) {
        shiftl128(&LOWER_P(number), (value - 128), &UPPER_P(target));
        clear128(&LOWER_P(target));
    } else {
        clear256(target);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jb 0x378a
movq -0x18(%rbp), %rdi
callq 0x35f0
jmp 0x3885
cmpl $0x80, -0xc(%rbp)
jne 0x37b6
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
callq 0x3510
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x35c0
jmp 0x3883
cmpl $0x0, -0xc(%rbp)
jne 0x37ce
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3540
jmp 0x3881
cmpl $0x80, -0xc(%rbp)
jae 0x3838
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x28(%rbp), %rdx
callq 0x3650
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movl $0x80, %esi
subl -0xc(%rbp), %esi
leaq -0x38(%rbp), %rdx
callq 0x3890
leaq -0x58(%rbp), %rdx
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x39a0
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movl -0xc(%rbp), %esi
leaq -0x58(%rbp), %rdx
addq $0x10, %rdx
callq 0x3650
movq -0x18(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3540
jmp 0x387f
movl $0x100, %eax            # imm = 0x100
cmpl -0xc(%rbp), %eax
jbe 0x3874
cmpl $0x80, -0xc(%rbp)
jbe 0x3874
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movl -0xc(%rbp), %esi
subl $0x80, %esi
movq -0x18(%rbp), %rdx
callq 0x3650
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x35c0
jmp 0x387d
movq -0x18(%rbp), %rdi
callq 0x35f0
jmp 0x387f
jmp 0x3881
jmp 0x3883
jmp 0x3885
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/uint256.c
// Function: shiftr128
void shiftr128(const uint128_t *number, uint32_t value, uint128_t *target) {
    if (value >= 128) {
        clear128(target);
    } else if (value == 64) {
        UPPER_P(target) = 0;
        LOWER_P(target) = UPPER_P(number);
    } else if (value == 0) {
        copy128(target, number);
    } else if (value < 64) {
        uint128_t result;
        UPPER(result) = UPPER_P(number) >> value;
        LOWER(result) =
            (UPPER_P(number) << (64 - value)) + (LOWER_P(number) >> value);
        copy128(target, &result);
    } else if ((128 > value) && (value > 64)) {
        LOWER_P(target) = UPPER_P(number) >> (value - 64);
        UPPER_P(target) = 0;
    } else {
        clear128(target);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x80, -0xc(%rbp)
jb 0x38ba
movq -0x18(%rbp), %rdi
callq 0x35c0
jmp 0x3994
cmpl $0x40, -0xc(%rbp)
jne 0x38df
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3992
cmpl $0x0, -0xc(%rbp)
jne 0x38f7
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3510
jmp 0x3990
cmpl $0x40, -0xc(%rbp)
jae 0x3949
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
shrq %cl, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl $0x40, %ecx
subl -0xc(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdx
movl -0xc(%rbp), %ecx
shrq %cl, %rdx
movq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3510
jmp 0x398e
movl $0x80, %eax
cmpl -0xc(%rbp), %eax
jbe 0x3983
cmpl $0x40, -0xc(%rbp)
jbe 0x3983
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
subl $0x40, %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
jmp 0x398c
movq -0x18(%rbp), %rdi
callq 0x35c0
jmp 0x398e
jmp 0x3990
jmp 0x3992
jmp 0x3994
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/uint256.c
// Function: add128
void add128(const uint128_t *number1, const uint128_t *number2, uint128_t *target) {
    UPPER_P(target) =
        UPPER_P(number1) + UPPER_P(number2) +
        ((LOWER_P(number1) + LOWER_P(number2)) < LOWER_P(number1));
    LOWER_P(target) = LOWER_P(number1) + LOWER_P(number2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdx
addq 0x8(%rdx), %rax
movq -0x8(%rbp), %rdx
cmpq 0x8(%rdx), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/uint256.c
// Function: shiftl512
void shiftl512(const uint512_t *number, uint32_t value, uint512_t *target) {
    if (value >= 512) {
        clear512(target);
    } else if (value == 256) {
        copy256(&UPPER_P(target), &LOWER_P(number));
        clear256(&LOWER_P(target));
    } else if (value == 0) {
        copy512(target, number);
    } else if (value < 256) {
        uint256_t tmp1;
        uint256_t tmp2;
        uint512_t result;
        shiftl256(&UPPER_P(number), value, &tmp1);
        shiftr256(&LOWER_P(number), (256 - value), &tmp2);
        add256(&tmp1, &tmp2, &UPPER(result));
        shiftl256(&LOWER_P(number), value, &LOWER(result));
        copy512(target, &result);
    } else if ((512 > value) && (value > 256)) {
        shiftl256(&LOWER_P(number), (value - 256), &UPPER_P(target));
        clear256(&LOWER_P(target));
    } else {
        clear512(target);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x200, -0xc(%rbp)      # imm = 0x200
jb 0x3a3d
movq -0x18(%rbp), %rdi
callq 0x3620
jmp 0x3b41
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jne 0x3a69
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x20, %rsi
callq 0x3540
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x35f0
jmp 0x3b3f
cmpl $0x0, -0xc(%rbp)
jne 0x3a81
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3580
jmp 0x3b3d
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jae 0x3af4
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x38(%rbp), %rdx
callq 0x3760
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movl $0x100, %esi            # imm = 0x100
subl -0xc(%rbp), %esi
leaq -0x58(%rbp), %rdx
callq 0x3b50
leaq -0x98(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3c70
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movl -0xc(%rbp), %esi
leaq -0x98(%rbp), %rdx
addq $0x20, %rdx
callq 0x3760
movq -0x18(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x3580
jmp 0x3b3b
movl $0x200, %eax            # imm = 0x200
cmpl -0xc(%rbp), %eax
jbe 0x3b30
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jbe 0x3b30
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movl -0xc(%rbp), %esi
subl $0x100, %esi            # imm = 0x100
movq -0x18(%rbp), %rdx
callq 0x3760
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x35f0
jmp 0x3b39
movq -0x18(%rbp), %rdi
callq 0x3620
jmp 0x3b3b
jmp 0x3b3d
jmp 0x3b3f
jmp 0x3b41
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/uint256.c
// Function: shiftr256
void shiftr256(const uint256_t *number, uint32_t value, uint256_t *target) {
    if (value >= 256) {
        clear256(target);
    } else if (value == 128) {
        copy128(&LOWER_P(target), &UPPER_P(number));
        clear128(&UPPER_P(target));
    } else if (value == 0) {
        copy256(target, number);
    } else if (value < 128) {
        uint128_t tmp1;
        uint128_t tmp2;
        uint256_t result;
        shiftr128(&UPPER_P(number), value, &UPPER(result));
        shiftr128(&LOWER_P(number), value, &tmp1);
        shiftl128(&UPPER_P(number), (128 - value), &tmp2);
        add128(&tmp1, &tmp2, &LOWER(result));
        copy256(target, &result);
    } else if ((256 > value) && (value > 128)) {
        shiftr128(&UPPER_P(number), (value - 128), &LOWER_P(target));
        clear128(&UPPER_P(target));
    } else {
        clear256(target);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jb 0x3b7a
movq -0x18(%rbp), %rdi
callq 0x35f0
jmp 0x3c69
cmpl $0x80, -0xc(%rbp)
jne 0x3ba2
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
callq 0x3510
movq -0x18(%rbp), %rdi
callq 0x35c0
jmp 0x3c67
cmpl $0x0, -0xc(%rbp)
jne 0x3bba
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3540
jmp 0x3c65
cmpl $0x80, -0xc(%rbp)
jae 0x3c20
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x58(%rbp), %rdx
callq 0x3890
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movl -0xc(%rbp), %esi
leaq -0x28(%rbp), %rdx
callq 0x3890
movq -0x8(%rbp), %rdi
movl $0x80, %esi
subl -0xc(%rbp), %esi
leaq -0x38(%rbp), %rdx
callq 0x3650
leaq -0x58(%rbp), %rdx
addq $0x10, %rdx
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x39a0
movq -0x18(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3540
jmp 0x3c63
movl $0x100, %eax            # imm = 0x100
cmpl -0xc(%rbp), %eax
jbe 0x3c58
cmpl $0x80, -0xc(%rbp)
jbe 0x3c58
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
subl $0x80, %esi
movq -0x18(%rbp), %rdx
addq $0x10, %rdx
callq 0x3890
movq -0x18(%rbp), %rdi
callq 0x35c0
jmp 0x3c61
movq -0x18(%rbp), %rdi
callq 0x35f0
jmp 0x3c63
jmp 0x3c65
jmp 0x3c67
jmp 0x3c69
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/uint256.c
// Function: add256
void add256(const uint256_t *number1, const uint256_t *number2, uint256_t *target) {
    uint128_t tmp;
    add128(&UPPER_P(number1), &UPPER_P(number2), &UPPER_P(target));
    add128(&LOWER_P(number1), &LOWER_P(number2), &tmp);
    if (gt128(&LOWER_P(number1), &tmp)) {
        uint128_t one;
        UPPER(one) = 0;
        LOWER(one) = 1;
        add128(&UPPER_P(target), &one, &UPPER_P(target));
    }
    add128(&LOWER_P(number1), &LOWER_P(number2), &LOWER_P(target));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x39a0
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
leaq -0x28(%rbp), %rdx
callq 0x39a0
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
leaq -0x28(%rbp), %rsi
callq 0x41d0
testb $0x1, %al
jne 0x3cc5
jmp 0x3ce6
movq $0x0, -0x38(%rbp)
movq $0x1, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rsi
callq 0x39a0
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movq -0x18(%rbp), %rdx
addq $0x10, %rdx
callq 0x39a0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/uint256.c
// Function: shiftr512
void shiftr512(const uint512_t *number, uint32_t value, uint512_t *target) {
    if (value >= 512) {
        clear512(target);
    } else if (value == 256) {
        copy256(&LOWER_P(target), &UPPER_P(number));
        clear256(&UPPER_P(target));
    } else if (value == 0) {
        copy512(target, number);
    } else if (value < 256) {
        uint256_t tmp1;
        uint256_t tmp2;
        uint512_t result;
        shiftr256(&UPPER_P(number), value, &UPPER(result));
        shiftr256(&LOWER_P(number), value, &tmp1);
        shiftl256(&UPPER_P(number), (256 - value), &tmp2);
        add256(&tmp1, &tmp2, &LOWER(result));
        copy512(target, &result);
    } else if ((512 > value) && (value > 256)) {
        shiftr256(&UPPER_P(number), (value - 256), &LOWER_P(target));
        clear256(&UPPER_P(target));
    } else {
        clear512(target);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x200, -0xc(%rbp)      # imm = 0x200
jb 0x3d3d
movq -0x18(%rbp), %rdi
callq 0x3620
jmp 0x3e35
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jne 0x3d65
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movq -0x8(%rbp), %rsi
callq 0x3540
movq -0x18(%rbp), %rdi
callq 0x35f0
jmp 0x3e33
cmpl $0x0, -0xc(%rbp)
jne 0x3d7d
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3580
jmp 0x3e31
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jae 0x3dec
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x98(%rbp), %rdx
callq 0x3b50
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movl -0xc(%rbp), %esi
leaq -0x38(%rbp), %rdx
callq 0x3b50
movq -0x8(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
subl -0xc(%rbp), %esi
leaq -0x58(%rbp), %rdx
callq 0x3760
leaq -0x98(%rbp), %rdx
addq $0x20, %rdx
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3c70
movq -0x18(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x3580
jmp 0x3e2f
movl $0x200, %eax            # imm = 0x200
cmpl -0xc(%rbp), %eax
jbe 0x3e24
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jbe 0x3e24
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
subl $0x100, %esi            # imm = 0x100
movq -0x18(%rbp), %rdx
addq $0x20, %rdx
callq 0x3b50
movq -0x18(%rbp), %rdi
callq 0x35f0
jmp 0x3e2d
movq -0x18(%rbp), %rdi
callq 0x3620
jmp 0x3e2f
jmp 0x3e31
jmp 0x3e33
jmp 0x3e35
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/uint256.c
// Function: shiftar256
void shiftar256(const uint256_t *number, uint32_t value, uint256_t *target) {
    bool positive = (UPPER(UPPER_P(number)) < 0x8000000000000000);
    shiftr256(number, value, target);
    if (positive) return;
    if (!value) return;
    if (value >= 64) {
        UPPER(UPPER_P(target)) = 0xffffffffffffffffllu;
        if (value >= 128) {
            LOWER(UPPER_P(target)) = 0xffffffffffffffffllu;
            if (value >= 192) {
                UPPER(LOWER_P(target)) = 0xffffffffffffffffllu;
                if (value >= 256) {
                    LOWER(LOWER_P(target)) = 0xffffffffffffffffllu;
                } else if (value > 192) {
                    LOWER(LOWER_P(target)) |= 0xffffffffffffffffllu - ((1llu << (256 - value)) - 1llu);
                }
            } else if (value > 128) {
                UPPER(LOWER_P(target)) |= 0xffffffffffffffffllu - ((1llu << (192 - value)) - 1llu);
            }
        } else if (value > 64) {
            LOWER(UPPER_P(target)) |= 0xffffffffffffffffllu - ((1llu << (128 - value)) - 1llu);
        }
    } else {
        UPPER(UPPER_P(target)) |= 0xffffffffffffffffllu - ((1llu << (64 - value)) - 1llu);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmpq %rcx, (%rax)
setb %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x3b50
testb $0x1, -0x19(%rbp)
je 0x3e87
jmp 0x3fc6
cmpl $0x0, -0xc(%rbp)
jne 0x3e92
jmp 0x3fc6
cmpl $0x40, -0xc(%rbp)
jb 0x3f9a
movq -0x18(%rbp), %rax
movq $-0x1, (%rax)
cmpl $0x80, -0xc(%rbp)
jb 0x3f62
movq -0x18(%rbp), %rax
movq $-0x1, 0x8(%rax)
cmpl $0xc0, -0xc(%rbp)
jb 0x3f27
movq -0x18(%rbp), %rax
movq $-0x1, 0x10(%rax)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jb 0x3eec
movq -0x18(%rbp), %rax
movq $-0x1, 0x18(%rax)
jmp 0x3f25
cmpl $0xc0, -0xc(%rbp)
jbe 0x3f23
movl $0x100, %eax            # imm = 0x100
subl -0xc(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq $-0x1, %rcx
subq %rax, %rcx
movq -0x18(%rbp), %rax
orq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
jmp 0x3f25
jmp 0x3f60
cmpl $0x80, -0xc(%rbp)
jbe 0x3f5e
movl $0xc0, %eax
subl -0xc(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq $-0x1, %rcx
subq %rax, %rcx
movq -0x18(%rbp), %rax
orq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
jmp 0x3f60
jmp 0x3f98
cmpl $0x40, -0xc(%rbp)
jbe 0x3f96
movl $0x80, %eax
subl -0xc(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq $-0x1, %rcx
subq %rax, %rcx
movq -0x18(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
jmp 0x3f98
jmp 0x3fc6
movl $0x40, %eax
subl -0xc(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq $-0x1, %rcx
subq %rax, %rcx
movq -0x18(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/uint256.c
// Function: bits128
uint32_t bits128(const uint128_t *number) {
    uint32_t result = 0;
    if (UPPER_P(number)) {
        result = 64;
        uint64_t up = UPPER_P(number);
        while (up) {
            up >>= 1;
            result++;
        }
    } else {
        uint64_t low = LOWER_P(number);
        while (low) {
            low >>= 1;
            result++;
        }
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x401a
movl $0x40, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4018
movq -0x18(%rbp), %rax
shrq %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3ffb
jmp 0x4045
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4043
movq -0x20(%rbp), %rax
shrq %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4026
jmp 0x4045
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/uint256.c
// Function: bits256
uint32_t bits256(const uint256_t *number) {
    if (!zero128(&UPPER_P(number))) {
        return 128 + bits128(&UPPER_P(number));
    } else {
        return bits128(&LOWER_P(number));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x34a0
testb $0x1, %al
jne 0x407c
movq -0x10(%rbp), %rdi
callq 0x3fd0
addl $0x80, %eax
movl %eax, -0x4(%rbp)
jmp 0x408c
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x3fd0
movl %eax, -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/src/uint256.c
// Function: sgt256
bool sgt256(const uint256_t *number1, const uint256_t *number2) {
    return (
        UPPER(UPPER_P(number1)) >= 0x8000000000000000 == UPPER(UPPER_P(number2)) >= 0x8000000000000000
        ? gt256(number1, number2)
        : gt256(number2, number1)
    );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmpq %rcx, (%rax)
setae %al
andb $0x1, %al
movzbl %al, %eax
movq -0x10(%rbp), %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
cmpq %rdx, (%rcx)
setae %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x443e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4230
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
jmp 0x4453
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x4230
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/uint256.c
// Function: add512
void add512(const uint512_t *number1, const uint512_t *number2, uint512_t *target) {
    uint256_t tmp;
    add256(&UPPER_P(number1), &UPPER_P(number2), &UPPER_P(target));
    add256(&LOWER_P(number1), &LOWER_P(number2), &tmp);
    if (gt256(&LOWER_P(number1), &tmp)) {
        uint256_t one;
        clear128(&UPPER(one));
        UPPER(LOWER(one)) = 0;
        LOWER(LOWER(one)) = 1;
        add256(&UPPER_P(target), &one, &UPPER_P(target));
    }
    copy256(&LOWER_P(target), &tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3c70
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
leaq -0x38(%rbp), %rdx
callq 0x3c70
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
leaq -0x38(%rbp), %rsi
callq 0x4230
testb $0x1, %al
jne 0x44c5
jmp 0x44ef
leaq -0x58(%rbp), %rdi
callq 0x35c0
movq $0x0, -0x48(%rbp)
movq $0x1, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x58(%rbp), %rsi
callq 0x3c70
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
leaq -0x38(%rbp), %rsi
callq 0x3540
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/uint256.c
// Function: minus256
void minus256(const uint256_t *number1, const uint256_t *number2, uint256_t *target) {
    uint128_t tmp;
    minus128(&UPPER_P(number1), &UPPER_P(number2), &UPPER_P(target));
    minus128(&LOWER_P(number1), &LOWER_P(number2), &tmp);
    if (gt128(&tmp, &LOWER_P(number1))) {
        uint128_t one;
        UPPER(one) = 0;
        LOWER(one) = 1;
        minus128(&UPPER_P(target), &one, &UPPER_P(target));
    }
    minus128(&LOWER_P(number1), &LOWER_P(number2), &LOWER_P(target));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4510
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
leaq -0x28(%rbp), %rdx
callq 0x4510
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
leaq -0x28(%rbp), %rdi
callq 0x41d0
testb $0x1, %al
jne 0x45d5
jmp 0x45f6
movq $0x0, -0x38(%rbp)
movq $0x1, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rsi
callq 0x4510
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movq -0x18(%rbp), %rdx
addq $0x10, %rdx
callq 0x4510
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/uint256.c
// Function: minus512
void minus512(const uint512_t *number1, const uint512_t *number2, uint512_t *target) {
    uint256_t tmp;
    minus256(&UPPER_P(number1), &UPPER_P(number2), &UPPER_P(target));
    minus256(&LOWER_P(number1), &LOWER_P(number2), &tmp);
    if (gt256(&tmp, &LOWER_P(number1))) {
        uint256_t one;
        clear128(&UPPER(one));
        UPPER(LOWER(one)) = 0;
        LOWER(LOWER(one)) = 1;
        minus256(&UPPER_P(target), &one, &UPPER_P(target));
    }
    minus256(&LOWER_P(number1), &LOWER_P(number2), &LOWER_P(target));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4580
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
leaq -0x38(%rbp), %rdx
callq 0x4580
movq -0x8(%rbp), %rsi
addq $0x20, %rsi
leaq -0x38(%rbp), %rdi
callq 0x4230
testb $0x1, %al
jne 0x4675
jmp 0x469f
leaq -0x58(%rbp), %rdi
callq 0x35c0
movq $0x0, -0x48(%rbp)
movq $0x1, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x58(%rbp), %rsi
callq 0x4580
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
movq -0x18(%rbp), %rdx
addq $0x20, %rdx
callq 0x4580
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/uint256.c
// Function: exp256
void exp256(const uint256_t *base, const uint256_t *power, uint256_t *target) {
    uint256_t remaining, result;
    copy256(&remaining, power);
    UPPER(UPPER(result)) = 0;
    LOWER(UPPER(result)) = 0;
    UPPER(LOWER(result)) = 0;
    LOWER(LOWER(result)) = 1;
    uint256_t multiplier;
    copy256(&multiplier, base);
    while (!zero256(&remaining)) {
        if (LOWER(LOWER(remaining)) & 1) {
            mul256(&result, &multiplier, &result);
        }
        mul256(&multiplier, &multiplier, &multiplier);
        shiftr256(&remaining, 1, &remaining);
    }
    copy256(target, &result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3540
movq $0x0, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x1, -0x40(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x3540
leaq -0x38(%rbp), %rdi
callq 0x34d0
xorb $-0x1, %al
testb $0x1, %al
jne 0x5922
jmp 0x5962
movq -0x20(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x5940
leaq -0x58(%rbp), %rdx
leaq -0x78(%rbp), %rsi
movq %rdx, %rdi
callq 0x4cb0
leaq -0x78(%rbp), %rdx
movq %rdx, %rdi
movq %rdx, %rsi
callq 0x4cb0
leaq -0x38(%rbp), %rdx
movl $0x1, %esi
movq %rdx, %rdi
callq 0x3b50
jmp 0x5911
movq -0x18(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3540
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/uint256.c
// Function: divmod128
void divmod128(const uint128_t *l, const uint128_t *r, uint128_t *retDiv,
               uint128_t *retMod) {
    uint128_t copyd, adder, resDiv, resMod;
    uint128_t one;
    UPPER(one) = 0;
    LOWER(one) = 1;
    uint32_t diffBits = bits128(l) - bits128(r);
    clear128(&resDiv);
    copy128(&resMod, l);
    if (gt128(r, l)) {
        copy128(retMod, l);
        clear128(retDiv);
    } else {
        shiftl128(r, diffBits, &copyd);
        shiftl128(&one, diffBits, &adder);
        if (gt128(&copyd, &resMod)) {
            shiftr128(&copyd, 1, &copyd);
            shiftr128(&adder, 1, &adder);
        }
        while (gte128(&resMod, r)) {
            if (gte128(&resMod, &copyd)) {
                minus128(&resMod, &copyd, &resMod);
                or128(&resDiv, &adder, &resDiv);
            }
            shiftr128(&copyd, 1, &copyd);
            shiftr128(&adder, 1, &adder);
        }
        copy128(retDiv, &resDiv);
        copy128(retMod, &resMod);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x70(%rbp)
movq $0x1, -0x68(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3fd0
movl %eax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3fd0
movl %eax, %ecx
movl -0x78(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x74(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x35c0
movq -0x8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x3510
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x41d0
testb $0x1, %al
jne 0x5a43
jmp 0x5a5e
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3510
movq -0x18(%rbp), %rdi
callq 0x35c0
jmp 0x5b39
movq -0x10(%rbp), %rdi
movl -0x74(%rbp), %esi
leaq -0x30(%rbp), %rdx
callq 0x3650
movl -0x74(%rbp), %esi
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x3650
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x41d0
testb $0x1, %al
jne 0x5a91
jmp 0x5ab3
leaq -0x30(%rbp), %rdx
movl $0x1, %esi
movq %rdx, %rdi
callq 0x3890
leaq -0x40(%rbp), %rdx
movl $0x1, %esi
movq %rdx, %rdi
callq 0x3890
jmp 0x5ab5
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x42f0
testb $0x1, %al
jne 0x5ac8
jmp 0x5b1f
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x42f0
testb $0x1, %al
jne 0x5adb
jmp 0x5afb
leaq -0x60(%rbp), %rdx
leaq -0x30(%rbp), %rsi
movq %rdx, %rdi
callq 0x4510
leaq -0x50(%rbp), %rdx
leaq -0x40(%rbp), %rsi
movq %rdx, %rdi
callq 0x46d0
leaq -0x30(%rbp), %rdx
movl $0x1, %esi
movq %rdx, %rdi
callq 0x3890
leaq -0x40(%rbp), %rdx
movl $0x1, %esi
movq %rdx, %rdi
callq 0x3890
jmp 0x5ab5
movq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3510
movq -0x20(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3510
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/uint256.c
// Function: divmod256
void divmod256(const uint256_t *l, const uint256_t *r, uint256_t *retDiv, uint256_t *retMod) {
    if (gt256(r, l)) {
        copy256(retMod, l);
        clear256(retDiv);
    } else {
        uint256_t copyd, adder, resDiv, resMod;
        uint256_t one;
        clear256(&one);
        LOWER(LOWER(one)) = 1;
        uint32_t diffBits = bits256(l) - bits256(r);
        copy256(&resMod, l);
        shiftl256(r, diffBits, &copyd);
        shiftl256(&one, diffBits, &adder);
        if (gt256(&copyd, &resMod)) {
            shiftr256(&copyd, 1, &copyd);
            shiftr256(&adder, 1, &adder);
        }
        clear256(&resDiv);
        while (gte256(&resMod, r)) {
            if (gte256(&resMod, &copyd)) {
                minus256(&resMod, &copyd, &resMod);
                or256(&resDiv, &adder, &resDiv);
            }
            shiftr256(&copyd, 1, &copyd);
            shiftr256(&adder, 1, &adder);
        }
        copy256(retDiv, &resDiv);
        copy256(retMod, &resMod);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x4230
testb $0x1, %al
jne 0x5b7e
jmp 0x5b99
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3540
movq -0x18(%rbp), %rdi
callq 0x35f0
jmp 0x5ce2
leaq -0xc0(%rbp), %rdi
callq 0x35f0
movq $0x1, -0xa8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4050
movl %eax, -0xc8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4050
movl %eax, %ecx
movl -0xc8(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xc4(%rbp)
movq -0x8(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x3540
movq -0x10(%rbp), %rdi
movl -0xc4(%rbp), %esi
leaq -0x40(%rbp), %rdx
callq 0x3760
movl -0xc4(%rbp), %esi
leaq -0xc0(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x3760
leaq -0x40(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x4230
testb $0x1, %al
jne 0x5c27
jmp 0x5c49
leaq -0x40(%rbp), %rdx
movl $0x1, %esi
movq %rdx, %rdi
callq 0x3b50
leaq -0x60(%rbp), %rdx
movl $0x1, %esi
movq %rdx, %rdi
callq 0x3b50
leaq -0x80(%rbp), %rdi
callq 0x35f0
movq -0x10(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x4340
testb $0x1, %al
jne 0x5c68
jmp 0x5cc5
leaq -0xa0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4340
testb $0x1, %al
jne 0x5c7e
jmp 0x5ca1
leaq -0xa0(%rbp), %rdx
leaq -0x40(%rbp), %rsi
movq %rdx, %rdi
callq 0x4580
leaq -0x80(%rbp), %rdx
leaq -0x60(%rbp), %rsi
movq %rdx, %rdi
callq 0x4710
leaq -0x40(%rbp), %rdx
movl $0x1, %esi
movq %rdx, %rdi
callq 0x3b50
leaq -0x60(%rbp), %rdx
movl $0x1, %esi
movq %rdx, %rdi
callq 0x3b50
jmp 0x5c52
movq -0x18(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x3540
movq -0x20(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x3540
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/uint256.c
// Function: divmod512
void divmod512(const uint512_t *l, const uint512_t *r, uint512_t *retDiv, uint512_t *retMod) {
    if (gt512(r, l)) {
        copy512(retMod, l);
        clear512(retDiv);
    } else {
        uint512_t copyd, adder, resDiv, resMod;
        uint512_t one;
        clear512(&one);
        LOWER(LOWER(LOWER(one))) = 1;
        uint32_t diffBits = bits512(l) - bits512(r);
        copy512(&resMod, l);
        shiftl512(r, diffBits, &copyd);
        shiftl512(&one, diffBits, &adder);
        if (gt512(&copyd, &resMod)) {
            shiftr512(&copyd, 1, &copyd);
            shiftr512(&adder, 1, &adder);
        }
        clear512(&resDiv);
        while (gte512(&resMod, r)) {
            if (gte512(&resMod, &copyd)) {
                minus512(&resMod, &copyd, &resMod);
                or512(&resDiv, &adder, &resDiv);
            }
            shiftr512(&copyd, 1, &copyd);
            shiftr512(&adder, 1, &adder);
        }
        copy512(retDiv, &resDiv);
        copy512(retMod, &resMod);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x4290
testb $0x1, %al
jne 0x5d1e
jmp 0x5d39
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3580
movq -0x18(%rbp), %rdi
callq 0x3620
jmp 0x5e97
leaq -0x160(%rbp), %rdi
callq 0x3620
movq $0x1, -0x128(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40a0
movl %eax, -0x168(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40a0
movl %eax, %ecx
movl -0x168(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x164(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x120(%rbp), %rdi
callq 0x3580
movq -0x10(%rbp), %rdi
movl -0x164(%rbp), %esi
leaq -0x60(%rbp), %rdx
callq 0x3a10
movl -0x164(%rbp), %esi
leaq -0x160(%rbp), %rdi
leaq -0xa0(%rbp), %rdx
callq 0x3a10
leaq -0x60(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x4290
testb $0x1, %al
jne 0x5dca
jmp 0x5def
leaq -0x60(%rbp), %rdx
movl $0x1, %esi
movq %rdx, %rdi
callq 0x3d10
leaq -0xa0(%rbp), %rdx
movl $0x1, %esi
movq %rdx, %rdi
callq 0x3d10
leaq -0xe0(%rbp), %rdi
callq 0x3620
movq -0x10(%rbp), %rsi
leaq -0x120(%rbp), %rdi
callq 0x4390
testb $0x1, %al
jne 0x5e11
jmp 0x5e77
leaq -0x120(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4390
testb $0x1, %al
jne 0x5e27
jmp 0x5e50
leaq -0x120(%rbp), %rdx
leaq -0x60(%rbp), %rsi
movq %rdx, %rdi
callq 0x4620
leaq -0xe0(%rbp), %rdx
leaq -0xa0(%rbp), %rsi
movq %rdx, %rdi
callq 0x4760
leaq -0x60(%rbp), %rdx
movl $0x1, %esi
movq %rdx, %rdi
callq 0x3d10
leaq -0xa0(%rbp), %rdx
movl $0x1, %esi
movq %rdx, %rdi
callq 0x3d10
jmp 0x5dfb
movq -0x18(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x3580
movq -0x20(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x3580
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/uint256.c
// Function: addmod256
void addmod256(const uint256_t *number1, const uint256_t *number2, const uint256_t *divisor, uint256_t *target) {
    uint512_t one, two, sum, three, result;
    clear256(&UPPER_P(&one));
    clear256(&UPPER_P(&two));
    clear256(&UPPER_P(&three));
    copy256(&LOWER_P(&one), number1);
    copy256(&LOWER_P(&two), number2);
    copy256(&LOWER_P(&three), divisor);
    add512(&one, &two, &sum);
    if (zero256(&UPPER(sum))) {
        divmod256(&LOWER(sum), divisor, &LOWER(one), target);
    } else {
        copy256(&LOWER(two), divisor);
        divmod512(&sum, &two, &one, &result);
        copy256(target, &LOWER(result));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x35f0
leaq -0xa0(%rbp), %rdi
callq 0x35f0
leaq -0x120(%rbp), %rdi
callq 0x35f0
leaq -0x60(%rbp), %rdi
addq $0x20, %rdi
movq -0x8(%rbp), %rsi
callq 0x3540
leaq -0xa0(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0x3540
leaq -0x120(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
callq 0x3540
leaq -0x60(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0xe0(%rbp), %rdx
callq 0x4470
leaq -0xe0(%rbp), %rdi
callq 0x34d0
testb $0x1, %al
jne 0x5f3e
jmp 0x5f60
leaq -0xe0(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
leaq -0x60(%rbp), %rdx
addq $0x20, %rdx
movq -0x20(%rbp), %rcx
callq 0x5b50
jmp 0x5fa6
leaq -0xa0(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
callq 0x3540
leaq -0xe0(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0x60(%rbp), %rdx
leaq -0x160(%rbp), %rcx
callq 0x5cf0
movq -0x20(%rbp), %rdi
leaq -0x160(%rbp), %rsi
addq $0x20, %rsi
callq 0x3540
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/uint256.c
// Function: tostring128
bool tostring128(const uint128_t *number, uint32_t baseParam, char *out,
                 uint32_t outLength) {
    if ((baseParam < 2) || (baseParam > 36)) {
        return false;
    }
    uint128_t rDiv;
    uint128_t rMod;
    uint128_t base;
    copy128(&rDiv, number);
    clear128(&base);
    LOWER(base) = baseParam;
    uint32_t offset = 0;
    do {
        if (offset > (outLength - 1)) {
            return false;
        }
        divmod128(&rDiv, &base, &rDiv, &rMod);
        out[offset++] = HEXDIGITS[LOWER(rMod)];
    } while (!zero128(&rDiv));
    out[offset] = '\0';
    reverseString(out, offset);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpl $0x2, -0x14(%rbp)
jb 0x60e2
cmpl $0x24, -0x14(%rbp)
jbe 0x60eb
movb $0x0, -0x1(%rbp)
jmp 0x6182
movq -0x10(%rbp), %rsi
leaq -0x34(%rbp), %rdi
callq 0x3510
leaq -0x54(%rbp), %rdi
callq 0x35c0
movl -0x14(%rbp), %eax
movq %rax, -0x4c(%rbp)
movl $0x0, -0x58(%rbp)
movl -0x58(%rbp), %eax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jbe 0x6122
movb $0x0, -0x1(%rbp)
jmp 0x6182
leaq -0x34(%rbp), %rdx
leaq -0x54(%rbp), %rsi
leaq -0x44(%rbp), %rcx
movq %rdx, %rdi
callq 0x59d0
movq -0x3c(%rbp), %rcx
leaq 0x207f(%rip), %rax      # 0x81c0
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movl -0x58(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x58(%rbp)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
leaq -0x34(%rbp), %rdi
callq 0x34a0
xorb $-0x1, %al
testb $0x1, %al
jne 0x610f
movq -0x20(%rbp), %rax
movl -0x58(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rdi
movl -0x58(%rbp), %esi
callq 0x6190
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/uint256.c
// Function: reverseString
static inline void reverseString(char *str, uint32_t length) {
    uint32_t i, j;
    for (i = 0, j = length - 1; i < j; i++, j--) {
        uint8_t c;
        c = str[i];
        str[i] = str[j];
        str[j] = c;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x61f5
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movb %dl, (%rax,%rcx)
movb -0x15(%rbp), %dl
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x61ab
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/uint256.c
// Function: tostring256
bool tostring256(const uint256_t *number, uint32_t baseParam, char *out,
                 uint32_t outLength) {
    if ((baseParam < 2) || (baseParam > 36)) {
        return false;
    }
    uint256_t rDiv;
    uint256_t rMod;
    uint256_t base;
    copy256(&rDiv, number);
    clear256(&base);
    UPPER(LOWER(base)) = 0;
    LOWER(LOWER(base)) = baseParam;
    uint32_t offset = 0;
    do {
        if (offset > (outLength - 1)) {
            return false;
        }
        divmod256(&rDiv, &base, &rDiv, &rMod);
        out[offset++] = HEXDIGITS[LOWER(LOWER(rMod))];
    } while (!zero256(&rDiv));
    out[offset] = '\0';
    reverseString(out, offset);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpl $0x2, -0x14(%rbp)
jb 0x6225
cmpl $0x24, -0x14(%rbp)
jbe 0x622e
movb $0x0, -0x1(%rbp)
jmp 0x62e5
movq -0x10(%rbp), %rsi
leaq -0x44(%rbp), %rdi
callq 0x3540
leaq -0x84(%rbp), %rdi
callq 0x35f0
movq $0x0, -0x74(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x6c(%rbp)
movl $0x0, -0x88(%rbp)
movl -0x88(%rbp), %eax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jbe 0x6276
movb $0x0, -0x1(%rbp)
jmp 0x62e5
leaq -0x44(%rbp), %rdx
leaq -0x84(%rbp), %rsi
leaq -0x64(%rbp), %rcx
movq %rdx, %rdi
callq 0x5b50
movq -0x4c(%rbp), %rcx
leaq 0x1f28(%rip), %rax      # 0x81c0
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movl -0x88(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x88(%rbp)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
leaq -0x44(%rbp), %rdi
callq 0x34d0
xorb $-0x1, %al
testb $0x1, %al
jne 0x6260
movq -0x20(%rbp), %rax
movl -0x88(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rdi
movl -0x88(%rbp), %esi
callq 0x6190
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/stack_array/stack2.c
// Function: create
Stack create(int initSize){
    Stack stack;
    if(initSize<MIN_STACK_SIZE){
        fatal("stack size is too small");
    }
    stack=(Stack)malloc(sizeof(struct STACK));
    if(stack==NULL){
        fatal("stack malloc failed.");
    }
    stack->data=malloc(sizeof(int)*initSize);
    stack->size=initSize;
    clear(stack);
    return stack;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x5, -0x4(%rbp)
jge 0x11ad
leaq 0xe5c(%rip), %rdi       # 0x2004
callq 0x1210
movl $0x10, %edi
callq 0x1060
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x11ce
leaq 0xe53(%rip), %rdi       # 0x201c
callq 0x1210
movslq -0x4(%rbp), %rdi
shlq $0x2, %rdi
callq 0x1060
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x1240
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/stack_array/stack2.c
// Function: push
void push(int value, Stack s){
    assert(s!=NULL);
    if(isFull(s)){
        fatal("stack is full");
    }
    //s->data[++s->top]=value;
    ++s->top;
    s->data[s->top]=value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1378
jmp 0x1397
leaq 0xcb2(%rip), %rdi       # 0x2031
leaq 0xcb3(%rip), %rsi       # 0x2039
movl $0x2d, %edx
leaq 0xce9(%rip), %rcx       # 0x207b
callq 0x1050
movq -0x10(%rbp), %rdi
callq 0x1330
cmpl $0x0, %eax
je 0x13b1
leaq 0xce5(%rip), %rdi       # 0x2091
callq 0x1210
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movl -0x4(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x4(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/stack_array/stack2.c
// Function: pop
void pop(Stack s){
    assert(s!=NULL);
    if(isEmpty(s)){
        fatal("stack is empty.");
    }
    s->top--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x13f5
jmp 0x1414
leaq 0xc35(%rip), %rdi       # 0x2031
leaq 0xc36(%rip), %rsi       # 0x2039
movl $0x36, %edx
leaq 0xc90(%rip), %rcx       # 0x209f
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x12e0
cmpl $0x0, %eax
je 0x142e
leaq 0xc86(%rip), %rdi       # 0x20af
callq 0x1210
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/stack_array/stack2.c
// Function: top
int top(Stack s){
    assert(s!=NULL);
    if(isEmpty(s)){
        fatal("stack is empty.");
    }
    return s->data[s->top];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1465
jmp 0x1484
leaq 0xbc5(%rip), %rdi       # 0x2031
leaq 0xbc6(%rip), %rsi       # 0x2039
movl $0x3d, %edx
leaq 0xc40(%rip), %rcx       # 0x20bf
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x12e0
cmpl $0x0, %eax
je 0x149e
leaq 0xc16(%rip), %rdi       # 0x20af
callq 0x1210
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x4(%rcx), %rcx
movl (%rax,%rcx,4), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)