LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/scan.c
// Function: fprintLabels
void fprintLabels(FILE *stream) {
    fputc('{', stream);
    for (uint32_t i = 0; i < labelCount; i++) {
        if (i) {
            fputc(',', stream);
        }
        fputc('\n', stream);
        fputc('\t', stream);
        fputc('"', stream);
        fprintLabel(stream, labels + i);
        fputc('"', stream);
        fprintf(stream, ": \"0x%04x\"", labelLocations[i]);
    }
    if (labelCount) {
        fputc('\n', stream);
    }
    fputc('}', stream);
    fputc('\n', stream);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movl $0x7b, %edi
callq 0x3180
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x2048e6e(%rip), %eax   # 0x2060e28
jae 0x18055
cmpl $0x0, -0xc(%rbp)
je 0x17fd4
movq -0x8(%rbp), %rsi
movl $0x2c, %edi
callq 0x3180
movq -0x8(%rbp), %rsi
movl $0xa, %edi
callq 0x3180
movq -0x8(%rbp), %rsi
movl $0x9, %edi
callq 0x3180
movq -0x8(%rbp), %rsi
movl $0x22, %edi
callq 0x3180
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
leaq 0x2048e24(%rip), %rsi   # 0x2060e30
shlq $0x4, %rax
addq %rax, %rsi
callq 0x18090
movq -0x8(%rbp), %rsi
movl $0x22, %edi
callq 0x3180
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x204d5fa(%rip), %rax   # 0x2065630
movl (%rax,%rcx,4), %edx
leaq 0x4371(%rip), %rsi      # 0x1c3b1
movb $0x0, %al
callq 0x31e0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x17fb1
cmpl $0x0, 0x2048dcc(%rip)   # 0x2060e28
je 0x1806c
movq -0x8(%rbp), %rsi
movl $0xa, %edi
callq 0x3180
movq -0x8(%rbp), %rsi
movl $0x7d, %edi
callq 0x3180
movq -0x8(%rbp), %rsi
movl $0xa, %edi
callq 0x3180
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/scan.c
// Function: scanWaste
static inline char scanWaste(const char **iter) {
    char ch;
    for (; shouldIgnore(ch = **iter) && ch; (*iter)++) {
        if (ch == '\n') {
            lineNumber++;
        }
    }
    if (ch == '/') {
        scanComment(iter);
        return scanWaste(iter);
    }
    return ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movsbl %al, %edi
callq 0x18780
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x12(%rbp)
je 0x182d9
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
testb $0x1, %al
jne 0x182e2
jmp 0x1830c
movsbl -0x11(%rbp), %eax
cmpl $0xa, %eax
jne 0x182fa
movl 0x2048b27(%rip), %eax   # 0x2060e18
addl $0x1, %eax
movl %eax, 0x2048b1e(%rip)   # 0x2060e18
jmp 0x182fc
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x182ac
movsbl -0x11(%rbp), %eax
cmpl $0x2f, %eax
jne 0x1832c
movq -0x10(%rbp), %rdi
callq 0x18880
movq -0x10(%rbp), %rdi
callq 0x182a0
movb %al, -0x1(%rbp)
jmp 0x18332
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/scan.c
// Function: scanLabel
static void scanLabel(const char **iter) {
    const char *start = *iter;
    for (char ch; isLowerCase(**iter); (*iter)++);
    const char *end = *iter;
    char next = scanWaste(iter);
    if (next == ':') {
        (*iter)++;
        scanstackPushLabel(start, end - start, JUMPDEST);
    } else {
        scanstackPushLabel(start, end - start, STOP);
        scanstackPush(PUSH1);
    }
    scanWaste(iter);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %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 0x17e20
cmpl $0x0, %eax
je 0x1839d
jmp 0x1838d
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x18377
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x182a0
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x3a, %eax
jne 0x183e6
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
subq %rax, %rsi
movl $0x5b, %edx
callq 0x188d0
jmp 0x18406
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
subq %rax, %rsi
xorl %edx, %edx
callq 0x188d0
movl $0x60, %edi
callq 0x171e0
movq -0x8(%rbp), %rdi
callq 0x182a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/scan.c
// Function: scanDataLen
static void scanDataLen(const char **iter) {
    (*iter)++; // '#'
    scanWaste(iter);
    const char *start = *iter;
    if (!isLowerCase(*start)) {
        fprintf(stderr, "Data section #keys should be lowercase; instead found unexpected character %c at line %u\n", *start, lineNumber);
    }
    for (char ch; isLowerCase(**iter); (*iter)++);
    const char *end = *iter;

    scanstackPushLabel(start, end - start, CODESIZE);
    scanstackPush(PUSH1);

    scanWaste(iter);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x182a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x17e20
cmpl $0x0, %eax
jne 0x18664
movq 0x79b2(%rip), %rax      # 0x1fff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movsbl (%rax), %edx
movl 0x20487c2(%rip), %ecx   # 0x2060e18
leaq 0x3f26(%rip), %rsi      # 0x1c583
movb $0x0, %al
callq 0x31e0
jmp 0x18666
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x17e20
cmpl $0x0, %eax
je 0x1868c
jmp 0x1867c
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x18666
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
subq %rax, %rsi
movl $0x38, %edx
callq 0x188d0
movl $0x60, %edi
callq 0x171e0
movq -0x8(%rbp), %rdi
callq 0x182a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/scan.c
// Function: scanChar
static void scanChar(const char **iter, char expected) {
    for (char ch; (ch = **iter) != expected; (*iter)++) {
        if (ch == '\n') {
            lineNumber++;
        }
        if (!shouldIgnore(ch)) {
            fprintf(stderr, "When seeking %c found unexpected character %c at line %u", expected, ch, lineNumber);
            exit(1);
        }
    }
    (*iter)++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0xa(%rbp)
movsbl %al, %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
je 0x18762
movsbl -0xa(%rbp), %eax
cmpl $0xa, %eax
jne 0x18711
movl 0x2048710(%rip), %eax   # 0x2060e18
addl $0x1, %eax
movl %eax, 0x2048707(%rip)   # 0x2060e18
movsbl -0xa(%rbp), %edi
callq 0x18780
cmpl $0x0, %eax
jne 0x18750
movq 0x78d2(%rip), %rax      # 0x1fff8
movq (%rax), %rdi
movsbl -0x9(%rbp), %edx
movsbl -0xa(%rbp), %ecx
movl 0x20486e0(%rip), %r8d   # 0x2060e18
leaq 0x3e9e(%rip), %rsi      # 0x1c5dd
movb $0x0, %al
callq 0x31e0
movl $0x1, %edi
callq 0x3280
jmp 0x18752
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x186e2
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/scan.c
// Function: shouldIgnore
static inline int shouldIgnore(char ch) {
    return ch != '('
        && ch != ')'
        && ch != ','
        && ch != ':'
        && ch != '/'
        && ch != '-'
        && ch != '{'
        && ch != '}'
        && ch != '#'
        && (ch < '0' || ch > '9')
        && (ch < 'A' || ch > 'Z')
        && (ch < 'a' || ch > 'z')
    ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %ecx
xorl %eax, %eax
cmpl $0x28, %ecx
movb %al, -0x2(%rbp)
je 0x1886b
movsbl -0x1(%rbp), %ecx
xorl %eax, %eax
cmpl $0x29, %ecx
movb %al, -0x2(%rbp)
je 0x1886b
movsbl -0x1(%rbp), %ecx
xorl %eax, %eax
cmpl $0x2c, %ecx
movb %al, -0x2(%rbp)
je 0x1886b
movsbl -0x1(%rbp), %ecx
xorl %eax, %eax
cmpl $0x3a, %ecx
movb %al, -0x2(%rbp)
je 0x1886b
movsbl -0x1(%rbp), %ecx
xorl %eax, %eax
cmpl $0x2f, %ecx
movb %al, -0x2(%rbp)
je 0x1886b
movsbl -0x1(%rbp), %ecx
xorl %eax, %eax
cmpl $0x2d, %ecx
movb %al, -0x2(%rbp)
je 0x1886b
movsbl -0x1(%rbp), %ecx
xorl %eax, %eax
cmpl $0x7b, %ecx
movb %al, -0x2(%rbp)
je 0x1886b
movsbl -0x1(%rbp), %ecx
xorl %eax, %eax
cmpl $0x7d, %ecx
movb %al, -0x2(%rbp)
je 0x1886b
movsbl -0x1(%rbp), %ecx
xorl %eax, %eax
cmpl $0x23, %ecx
movb %al, -0x2(%rbp)
je 0x1886b
movsbl -0x1(%rbp), %eax
cmpl $0x30, %eax
jl 0x18833
movsbl -0x1(%rbp), %ecx
xorl %eax, %eax
cmpl $0x39, %ecx
movb %al, -0x2(%rbp)
jle 0x1886b
movsbl -0x1(%rbp), %eax
cmpl $0x41, %eax
jl 0x1884a
movsbl -0x1(%rbp), %ecx
xorl %eax, %eax
cmpl $0x5a, %ecx
movb %al, -0x2(%rbp)
jle 0x1886b
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x61, %ecx
movb %al, -0x3(%rbp)
jl 0x18865
movsbl -0x1(%rbp), %eax
cmpl $0x7a, %eax
setg %al
movb %al, -0x3(%rbp)
movb -0x3(%rbp), %al
movb %al, -0x2(%rbp)
movb -0x2(%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/include/scanstack.h
// Function: scanstackPushLabel
static inline void scanstackPushLabel(const char *start, size_t len, op_t type) {
    label_t *label = (label_t *)malloc(sizeof(label_t));
    label->start = start;
    label->length = len;
    scanstackPush(type);
    labelstack[scanstackIndex] = label;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x10, %edi
callq 0x3210
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movzbl -0x11(%rbp), %edi
callq 0x171e0
movq -0x20(%rbp), %rdx
movzbl 0x20484fe(%rip), %eax   # 0x2060e1c
movl %eax, %ecx
leaq 0x204e119(%rip), %rax   # 0x2066a40
movq %rdx, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/disassemble.c
// Function: labelForPc
statement_t labelForPc(pc_t pc) {
    const size_t bufLen = 8;
    char *str = calloc(bufLen, 1);
    size_t strLen = (size_t) snprintf(str, bufLen, "%u:", pc);
    /*  TODO label
    for (uint8_t i = 0; i < strLen - 1; i++) {
        str[i] += 'a' - '0';
    }
    */
    return (statement_t) {
        strLen,
        str,
        bufLen,
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x4(%rbp)
movq $0x8, -0x10(%rbp)
movl $0x8, %edi
movl $0x1, %esi
callq 0x31c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0x4(%rbp), %ecx
movl $0x8, %esi
leaq 0x3bac(%rip), %rdx      # 0x1c65d
movb $0x0, %al
callq 0x3110
movq -0x30(%rbp), %rdi
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, (%rdi)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rdi)
movq $0x8, 0x10(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/disassemble.c
// Function: disassembleWaste
static void disassembleWaste(const char **iter) {
    while (**iter && !isHex(**iter)) {
        (*iter)++;
    }
    if (**iter == '0' && *(*iter + 1) == 'x') {
        *iter += 2;
        disassembleWaste(iter);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x9(%rbp)
je 0x18e0a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x19250
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x18e13
jmp 0x18e23
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x18ddc
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x18e59
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x78, %eax
jne 0x18e59
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x18dd0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/disassemble.c
// Function: disassemblePush
static void disassemblePush(op_t op, const char **iter) {
    uint8_t pushlen = op - PUSH1 + 1;
    if (pushlen <= 3) {
        disassemblePushDecimal(op, pushlen, iter);
    } else {
        disassemblePushHex(op, pushlen, iter);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movzbl -0x1(%rbp), %eax
subl $0x60, %eax
addl $0x1, %eax
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x3, %eax
jg 0x18edf
movb -0x1(%rbp), %cl
movb -0x11(%rbp), %al
movq -0x10(%rbp), %rdx
movzbl %cl, %edi
movzbl %al, %esi
callq 0x19380
jmp 0x18ef4
movb -0x1(%rbp), %cl
movb -0x11(%rbp), %al
movq -0x10(%rbp), %rdx
movzbl %cl, %edi
movzbl %al, %esi
callq 0x194d0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/disassemble.c
// Function: disassembleFinalize
void disassembleFinalize() {
    for (size_t j = 0; j < jumpdests.num_pcs; j++) {
        size_t jumpdest = jumpdests.pcs[j]; 
        for (size_t i = 0; i < stack.num_statements; i++) {
            // TODO scan for label
        }
    }
    for (size_t i = 0; i < stack.num_statements; i++) {
        puts(stack.statements[i].schars);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq 0x204f88d(%rip), %rax   # 0x2068a48
jae 0x19204
movq 0x204f88c(%rip), %rax   # 0x2068a50
movq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x204f87e(%rip), %rax   # 0x2068a60
jae 0x191f4
jmp 0x191e6
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x191d7
jmp 0x191f6
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x191b0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq 0x204f849(%rip), %rax   # 0x2068a60
jae 0x1923f
movq 0x204f848(%rip), %rax   # 0x2068a68
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x30a0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1920c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/disassemble.c
// Function: disassemblePushDecimal
static void disassemblePushDecimal(op_t op, uint8_t pushlen, const char **iter) {
    uint64_t value = 0;
    while (pushlen) {
        disassembleWaste(iter);
        value *= 16;
        if (**iter) {
            value += hexString8ToUint8(*(*iter)++);
        }
        disassembleWaste(iter);
        value *= 16;
        if (**iter) {
            value += hexString8ToUint8(*(*iter)++);
        }
        pushlen--;
        pc++;
    }
    size_t bufLength = 20;
    char *str = (char *)calloc(bufLength, 1);
    int strLength = snprintf(str, bufLength, "%" PRIu64, value);
    statement_t pushDec = {
        strLength,
        str,
        bufLength
    };
    statement_stack_append(&stack, pushDec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movb %al, -0x2(%rbp)
movq %rdx, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpb $0x0, -0x2(%rbp)
je 0x19450
movq -0x10(%rbp), %rdi
callq 0x18dd0
movq -0x18(%rbp), %rax
shlq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0x193ef
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movzbl (%rax), %edi
callq 0x192d0
movzbl %al, %eax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x18dd0
movq -0x18(%rbp), %rax
shlq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0x19434
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movzbl (%rax), %edi
callq 0x192d0
movzbl %al, %eax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movb -0x2(%rbp), %al
addb $-0x1, %al
movb %al, -0x2(%rbp)
movl 0x204f5fe(%rip), %eax   # 0x2068a40
addl $0x1, %eax
movl %eax, 0x204f5f5(%rip)   # 0x2068a40
jmp 0x193a0
movq $0x14, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x31c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rcx
leaq 0x1703(%rip), %rdx      # 0x1ab80
movb $0x0, %al
callq 0x3110
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x204f5ba(%rip), %rdi   # 0x2068a60
leaq -0x48(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x190a0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/src/disassemble.c
// Function: disassemblePushHex
static void disassemblePushHex(op_t op, uint8_t pushlen, const char **iter) {
    size_t strLength = 2 * pushlen + 2;
    char *str = calloc(strLength, 1);
    str[0] = '0';
    str[1] = 'x';
    uint8_t i = 2;
    while (pushlen) {
        disassembleWaste(iter);
        if (**iter) {
            str[i++] = *(*iter)++;
        } else {
            str[i++] = '0';
        }
        disassembleWaste(iter);
        if (**iter) {
            str[i++] = *(*iter)++;
        } else {
            str[i++] = '0';
        }
        pushlen--;
        pc++;
    }
    statement_t pushHex = {
        strLength,
        str,
        strLength
    };
    statement_stack_append(&stack, pushHex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movb %al, -0x2(%rbp)
movq %rdx, -0x10(%rbp)
movzbl -0x2(%rbp), %eax
shll %eax
addl $0x2, %eax
cltq
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x31c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb $0x30, (%rax)
movq -0x20(%rbp), %rax
movb $0x78, 0x1(%rax)
movb $0x2, -0x21(%rbp)
cmpb $0x0, -0x2(%rbp)
je 0x195f2
movq -0x10(%rbp), %rdi
callq 0x18dd0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0x19568
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb (%rax), %dl
movq -0x20(%rbp), %rax
movb -0x21(%rbp), %cl
movb %cl, %sil
addb $0x1, %sil
movb %sil, -0x21(%rbp)
movzbl %cl, %ecx
movb %dl, (%rax,%rcx)
jmp 0x1957e
movq -0x20(%rbp), %rax
movb -0x21(%rbp), %cl
movb %cl, %dl
addb $0x1, %dl
movb %dl, -0x21(%rbp)
movzbl %cl, %ecx
movb $0x30, (%rax,%rcx)
movq -0x10(%rbp), %rdi
callq 0x18dd0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0x195c0
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb (%rax), %dl
movq -0x20(%rbp), %rax
movb -0x21(%rbp), %cl
movb %cl, %sil
addb $0x1, %sil
movb %sil, -0x21(%rbp)
movzbl %cl, %ecx
movb %dl, (%rax,%rcx)
jmp 0x195d6
movq -0x20(%rbp), %rax
movb -0x21(%rbp), %cl
movb %cl, %dl
addb $0x1, %dl
movb %dl, -0x21(%rbp)
movzbl %cl, %ecx
movb $0x30, (%rax,%rcx)
movb -0x2(%rbp), %al
addb $-0x1, %al
movb %al, -0x2(%rbp)
movl 0x204f45c(%rip), %eax   # 0x2068a40
addl $0x1, %eax
movl %eax, 0x204f453(%rip)   # 0x2068a40
jmp 0x1951c
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x204f44f(%rip), %rdi   # 0x2068a60
leaq -0x40(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x190a0
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: Get5bits(unsigned char const*, int)
unsigned char Get5bits(const unsigned char *in, int i) // selects bits 5*i to 5*i+4 out of an array of bytes, bit 0 = MSB
{
	unsigned int x = in[(5*i)/8] << 8; // select byte containing bit 5*i, move to upper 8 bits of 16-bit word
	if ((5*i)%8 > (8-5)) x |= in[((5*i)/8)+1]; // bit 5*i+4 is in another byte, add to lower 8 bits of 16-bit word

	x <<= (5*i)%8; // move bit 5*i to MSB of 16-bit word
	return (x&0xFFFF) >> (16-5); // select 5 highest bits of 16-bit word
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
imull $0x5, -0xc(%rsp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x18(%rsp), %rax
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
movl %eax, -0x10(%rsp)
imull $0x5, -0xc(%rsp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x3, %edx
jle 0x39c7
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
imull $0x5, -0xc(%rsp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x20(%rsp), %rax
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
orl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
imull $0x5, -0xc(%rsp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %edx, %ecx
movl -0x10(%rsp), %eax
shll %cl, %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
shrl $0xb, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: Get8bits(unsigned char const*, int)
unsigned char Get8bits(const unsigned char *in, int i) // selects bits 8*i to 8*i+7 out of an array of 5-bit elements, bit 0 = MSB
{
	unsigned int x = in[(8*i)/5] << 10; // select element containing bit 8*i, move to upper 5 bits of 15-bit word
	x |= (((in[((8*i)/5)+1]) & 0x3FF) << 5); // bit 8*i+7 is definitely in another element, add to middle 5 bits of 15-bit word
	if ((8*i)%5 > (10-8)) x |= ((in[((8*i)/5)+2]) & 0x3FF); // bit 8*i+7 is in yet another element, add to lower 5 bits of 10-bit word
	x <<= (8*i)%5; // move bit 8*i to MSB of 15-bit word
	return (x&0x7FFF) >> (15-8); // select 8 highest bits of 15-bit word
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movl -0xc(%rsp), %eax
shll $0x3, %eax
movl $0x5, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x20(%rsp), %rax
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0xa, %eax
movl %eax, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movl -0xc(%rsp), %eax
shll $0x3, %eax
movl $0x5, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x18(%rsp), %rax
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
andl $0x3ff, %eax            # imm = 0x3FF
shll $0x5, %eax
orl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0xc(%rsp), %eax
shll $0x3, %eax
movl $0x5, %ecx
cltd
idivl %ecx
cmpl $0x2, %edx
jle 0x3aac
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movl -0xc(%rsp), %eax
shll $0x3, %eax
movl $0x5, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x28(%rsp), %rax
addl $0x2, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
andl $0x3ff, %eax            # imm = 0x3FF
orl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0xc(%rsp), %eax
shll $0x3, %eax
movl $0x5, %ecx
cltd
idivl %ecx
movl %edx, %ecx
movl -0x10(%rsp), %eax
shll %cl, %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
andl $0x7fff, %eax           # imm = 0x7FFF
shrl $0x7, %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: PrintElementsStateHex(unsigned char*)
void PrintElementsStateHex(unsigned char *state) //prints the state in hexadecimal format element by element starting from a_{0,0} and row by row
{
	for(int j=0; j<NumberRows; j++){
		for(int i=0; i<NumberColumns; i++)
			printf(" %.2x", state[NumberColumns*j+i]);
		printf("\n");
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x5, 0xc(%rsp)
jge 0x3c14
movl $0x0, 0x8(%rsp)
cmpl $0x8, 0x8(%rsp)
jge 0x3bf9
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
shll $0x3, %ecx
addl 0x8(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %esi
leaq 0x141b(%rip), %rdi      # 0x5000
movb $0x0, %al
callq 0x2030
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x3bc0
leaq 0x1411(%rip), %rdi      # 0x5011
movb $0x0, %al
callq 0x2030
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3bb1
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: PrintElementsStateDec(unsigned char*)
void PrintElementsStateDec(unsigned char *state) //prints the state in decimal format element by element starting from a_{0,0} and row by row
{
	for(int j=0; j<NumberRows; j++){
		for(int i=0; i<NumberColumns; i++)
			printf(" %d", state[NumberColumns*j+i]);
		printf("\n");
	}
	printf("\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x5, 0xc(%rsp)
jge 0x3c94
movl $0x0, 0x8(%rsp)
cmpl $0x8, 0x8(%rsp)
jge 0x3c79
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
shll $0x3, %ecx
addl 0x8(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %esi
leaq 0x13a1(%rip), %rdi      # 0x5006
movb $0x0, %al
callq 0x2030
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x3c40
leaq 0x1391(%rip), %rdi      # 0x5011
movb $0x0, %al
callq 0x2030
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3c31
leaq 0x1376(%rip), %rdi      # 0x5011
movb $0x0, %al
callq 0x2030
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: ShiftRows(unsigned char*)
void ShiftRows(unsigned char *state) //ShiftRows operation on the state
{
	unsigned char tmp[StateSize];
	for(int j=0; j<NumberRows; j++){
		for(int i=0; i<NumberColumns; i++){
			tmp[NumberColumns*j+i]=state[NumberColumns*j+((i+shiftconst[j])%NumberColumns)];
		}
	}
	for(int j=0; j<StateSize; j++)
		state[j]=tmp[j];
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0x3c(%rsp)
cmpl $0x5, -0x3c(%rsp)
jge 0x3f59
movl $0x0, -0x40(%rsp)
cmpl $0x8, -0x40(%rsp)
jge 0x3f4a
movq -0x8(%rsp), %rax
movq %rax, -0x50(%rsp)
movl -0x3c(%rsp), %ecx
shll $0x3, %ecx
movl -0x40(%rsp), %eax
movslq -0x3c(%rsp), %rsi
movq 0x30d4(%rip), %rdx      # 0x6fe8
addl (%rdx,%rsi,4), %eax
movl $0x8, %esi
cltd
idivl %esi
movq -0x50(%rsp), %rax
addl %edx, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movl -0x3c(%rsp), %eax
shll $0x3, %eax
addl -0x40(%rsp), %eax
cltq
movb %cl, -0x38(%rsp,%rax)
movl -0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rsp)
jmp 0x3eec
jmp 0x3f4c
movl -0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rsp)
jmp 0x3edd
movl $0x0, -0x44(%rsp)
cmpl $0x28, -0x44(%rsp)
jge 0x3f8b
movslq -0x44(%rsp), %rax
movb -0x38(%rsp,%rax), %dl
movq -0x8(%rsp), %rax
movslq -0x44(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl -0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rsp)
jmp 0x3f61
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: ShiftRowsInv(unsigned char*)
void ShiftRowsInv(unsigned char *state) //Inverse ShiftRows operation on the state
{
	unsigned char tmp[StateSize];
	for(int j=0; j<NumberRows; j++){
		for(int i=0; i<NumberColumns; i++){
			tmp[NumberColumns*j+i]=state[NumberColumns*j+((i-shiftconst[j]+NumberColumns)%NumberColumns)];
		}
	}
	for(int j=0; j<StateSize; j++)
		state[j]=tmp[j];
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0x3c(%rsp)
cmpl $0x5, -0x3c(%rsp)
jge 0x401c
movl $0x0, -0x40(%rsp)
cmpl $0x8, -0x40(%rsp)
jge 0x400d
movq -0x8(%rsp), %rax
movq %rax, -0x50(%rsp)
movl -0x3c(%rsp), %ecx
shll $0x3, %ecx
movl -0x40(%rsp), %eax
movslq -0x3c(%rsp), %rsi
movq 0x3014(%rip), %rdx      # 0x6fe8
subl (%rdx,%rsi,4), %eax
addl $0x8, %eax
movl $0x8, %esi
cltd
idivl %esi
movq -0x50(%rsp), %rax
addl %edx, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movl -0x3c(%rsp), %eax
shll $0x3, %eax
addl -0x40(%rsp), %eax
cltq
movb %cl, -0x38(%rsp,%rax)
movl -0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rsp)
jmp 0x3fac
jmp 0x400f
movl -0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rsp)
jmp 0x3f9d
movl $0x0, -0x44(%rsp)
cmpl $0x28, -0x44(%rsp)
jge 0x404e
movslq -0x44(%rsp), %rax
movb -0x38(%rsp,%rax), %dl
movq -0x8(%rsp), %rax
movslq -0x44(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl -0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rsp)
jmp 0x4024
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: T18(unsigned char)
unsigned char T18(unsigned char element) //Field Multiplication by 18 of an element
{
	unsigned char tmp, t2, t4, t8, t16;
	t2=T2(element);
	t4=T2(t2);
	t8=T2(t4);
	t16=T2(t8);
	tmp=t16^t2; 
	return tmp;
}

// Assembly:
pushq %rax
movb %dil, %al
movb %al, 0x7(%rsp)
movzbl 0x7(%rsp), %edi
callq 0x20b0
movb %al, 0x5(%rsp)
movzbl 0x5(%rsp), %edi
callq 0x20b0
movb %al, 0x4(%rsp)
movzbl 0x4(%rsp), %edi
callq 0x20b0
movb %al, 0x3(%rsp)
movzbl 0x3(%rsp), %edi
callq 0x20b0
movb %al, 0x2(%rsp)
movzbl 0x2(%rsp), %eax
movzbl 0x5(%rsp), %ecx
xorl %ecx, %eax
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: MixColumns(unsigned char*)
void MixColumns(unsigned char *state) //MixColumns operation on the state
{
	unsigned char tmp[StateSize];
	for(int p=0; p<NumberRows; p++){
		for(int i=0; i<NumberColumns; i++){
			for(int j=0; j<(NumberRows-1); j++)
				tmp[NumberColumns*j+i]=state[NumberColumns*(j+1)+i];
			tmp[NumberColumns*4+i]=state[i]^T18(state[NumberColumns*1+i])^T2(state[NumberColumns*2+i])^T2(state[NumberColumns*3+i])^T18(state[NumberColumns*4+i]);
		}
		for(int j=0; j<StateSize; j++)
			state[j]=tmp[j];
	}
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0x5, 0x1c(%rsp)
jge 0x4270
movl $0x0, 0x18(%rsp)
cmpl $0x8, 0x18(%rsp)
jge 0x422c
movl $0x0, 0x14(%rsp)
cmpl $0x4, 0x14(%rsp)
jge 0x4165
movq 0x50(%rsp), %rax
movl 0x14(%rsp), %ecx
addl $0x1, %ecx
shll $0x3, %ecx
addl 0x18(%rsp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movl 0x14(%rsp), %eax
shll $0x3, %eax
addl 0x18(%rsp), %eax
cltq
movb %cl, 0x20(%rsp,%rax)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4127
movq 0x50(%rsp), %rax
movslq 0x18(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, (%rsp)
movq 0x50(%rsp), %rax
movl 0x18(%rsp), %ecx
addl $0x8, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
callq 0x2170
movb %al, %cl
movl (%rsp), %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movl %eax, 0x4(%rsp)
movq 0x50(%rsp), %rax
movl 0x18(%rsp), %ecx
addl $0x10, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
callq 0x20b0
movb %al, %cl
movl 0x4(%rsp), %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movl %eax, 0x8(%rsp)
movq 0x50(%rsp), %rax
movl 0x18(%rsp), %ecx
addl $0x18, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
callq 0x20b0
movb %al, %cl
movl 0x8(%rsp), %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movl %eax, 0xc(%rsp)
movq 0x50(%rsp), %rax
movl 0x18(%rsp), %ecx
addl $0x20, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
callq 0x2170
movb %al, %cl
movl 0xc(%rsp), %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movb %al, %cl
movl 0x18(%rsp), %eax
addl $0x20, %eax
cltq
movb %cl, 0x20(%rsp,%rax)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x4114
movl $0x0, 0x10(%rsp)
cmpl $0x28, 0x10(%rsp)
jge 0x425e
movslq 0x10(%rsp), %rax
movb 0x20(%rsp,%rax), %dl
movq 0x50(%rsp), %rax
movslq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x4234
jmp 0x4260
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4101
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: MixColumnsInv(unsigned char*)
void MixColumnsInv(unsigned char *state) //Inverse MixColumns operation on the state
{
	unsigned char tmp[StateSize];
	for(int p=0; p<NumberRows; p++){
		for(int i=0; i<NumberColumns; i++){
			tmp[i]=T18(state[i])^T2(state[NumberColumns*1+i])^T2(state[NumberColumns*2+i])^T18(state[NumberColumns*3+i])^state[NumberColumns*4+i];
 			for(int j=1; j<NumberRows; j++)
				tmp[NumberColumns*j+i]=state[NumberColumns*(j-1)+i];
		}
		for(int j=0; j<StateSize; j++)
			state[j]=tmp[j];
	}
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0x5, 0x1c(%rsp)
jge 0x43f6
movl $0x0, 0x18(%rsp)
cmpl $0x8, 0x18(%rsp)
jge 0x43b2
movq 0x50(%rsp), %rax
movslq 0x18(%rsp), %rcx
movzbl (%rax,%rcx), %edi
callq 0x2170
movzbl %al, %eax
movl %eax, 0x4(%rsp)
movq 0x50(%rsp), %rax
movl 0x18(%rsp), %ecx
addl $0x8, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
callq 0x20b0
movb %al, %cl
movl 0x4(%rsp), %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movl %eax, 0x8(%rsp)
movq 0x50(%rsp), %rax
movl 0x18(%rsp), %ecx
addl $0x10, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
callq 0x20b0
movb %al, %cl
movl 0x8(%rsp), %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movl %eax, 0xc(%rsp)
movq 0x50(%rsp), %rax
movl 0x18(%rsp), %ecx
addl $0x18, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
callq 0x2170
movb %al, %cl
movl 0xc(%rsp), %eax
movzbl %cl, %ecx
xorl %ecx, %eax
movq 0x50(%rsp), %rcx
movl 0x18(%rsp), %edx
addl $0x20, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %cl
movslq 0x18(%rsp), %rax
movb %cl, 0x20(%rsp,%rax)
movl $0x1, 0x14(%rsp)
cmpl $0x5, 0x14(%rsp)
jge 0x43a0
movq 0x50(%rsp), %rax
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
shll $0x3, %ecx
addl 0x18(%rsp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movl 0x14(%rsp), %eax
shll $0x3, %eax
addl 0x18(%rsp), %eax
cltq
movb %cl, 0x20(%rsp,%rax)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4362
jmp 0x43a2
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x42a4
movl $0x0, 0x10(%rsp)
cmpl $0x28, 0x10(%rsp)
jge 0x43e4
movslq 0x10(%rsp), %rax
movb 0x20(%rsp,%rax), %dl
movq 0x50(%rsp), %rax
movslq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x43ba
jmp 0x43e6
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4291
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: GenerateRoundConstants()
void GenerateRoundConstants() //Generation of 5-bit round constant by using the primitive polynomial x^5+x^2+1 with initial value 1.
{
	//Round constants for p_1
	rc_p1[0]=1;
	//printf("\nRound constants for p_1: \n %.2x", rc_p1[0]);
	for(int i=1; i<p1rounds; i++){
		rc_p1[i] = ((rc_p1[i-1]<<1) ^ ((rc_p1[i-1]>>1)&1) ^ ((rc_p1[i-1]>>4)&1))&31;
		//printf("\n %.2x", rc_p1[i]);
	}
}

// Assembly:
movq 0x2b61(%rip), %rax      # 0x6fc8
movb $0x1, (%rax)
movl $0x1, -0x4(%rsp)
cmpl $0xc, -0x4(%rsp)
jge 0x44ea
movl -0x4(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rcx
movq 0x2b3e(%rip), %rax      # 0x6fc8
movzbl (%rax,%rcx), %eax
shll %eax
movl -0x4(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rdx
movq 0x2b27(%rip), %rcx      # 0x6fc8
movzbl (%rcx,%rdx), %ecx
sarl %ecx
andl $0x1, %ecx
xorl %ecx, %eax
movl -0x4(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rdx
movq 0x2b0b(%rip), %rcx      # 0x6fc8
movzbl (%rcx,%rdx), %ecx
sarl $0x4, %ecx
andl $0x1, %ecx
xorl %ecx, %eax
andl $0x1f, %eax
movb %al, %dl
movslq -0x4(%rsp), %rcx
movq 0x2aee(%rip), %rax      # 0x6fc8
movb %dl, (%rax,%rcx)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x4472
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: InitializeState(unsigned char*, unsigned char*)
void InitializeState(unsigned char *state, unsigned char *key)
{
	GenerateRoundConstants();

	for(int i=0; i<RateSizeElements; i++)
		state[i]=0;
	for(int i=0; i<KeySizeElements; i++)
		state[RateSizeElements+i]=key[i];
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
callq 0x2150
movl $0x0, 0x4(%rsp)
cmpl $0x8, 0x4(%rsp)
jge 0x452d
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x450b
movl $0x0, (%rsp)
cmpl $0x20, (%rsp)
jge 0x4562
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x10(%rsp), %rax
movl (%rsp), %ecx
addl $0x8, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x4534
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: p_1(unsigned char*)
void p_1(unsigned char *state)
{
	for(int rnd=0; rnd<p1rounds; rnd++)
	{
		primate(state);	
		state[RateSizeElements+1]^=rc_p1[rnd];		
		//printf("\nState after AddConstant:\n\n\n"); PrintElementsStateDec(state);
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0xc, 0xc(%rsp)
jge 0x45bd
movq 0x10(%rsp), %rdi
callq 0x2140
movslq 0xc(%rsp), %rcx
movq 0x2a2a(%rip), %rax      # 0x6fc8
movzbl (%rax,%rcx), %edx
movq 0x10(%rsp), %rax
movzbl 0x9(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x9(%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4581
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: p_1_inv(unsigned char*)
void p_1_inv(unsigned char *state)
{
	for(int rnd=0; rnd<p1rounds; rnd++)
	{
		state[RateSizeElements+1]^=rc_p1[p1rounds-rnd-1];		
		//printf("\nState after AddConstant:\n\n\n"); PrintElementsStateDec(state);
		primateInv(state);	
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0xc, 0xc(%rsp)
jge 0x4627
movl $0xc, %eax
subl 0xc(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rcx
movq 0x29ca(%rip), %rax      # 0x6fc8
movzbl (%rax,%rcx), %edx
movq 0x10(%rsp), %rax
movzbl 0x9(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x9(%rax)
movq 0x10(%rsp), %rdi
callq 0x21a0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x45e1
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phase[P]o/o.c
// Function: dlo
V dlo(O o){
    switch(o->t){
    case TS:case TCB:DL(o->s.s);BK;
    case TA:while(len(o->a))dlo(pop(o->a));dls(o->a);BK;
    case TD:BK;
    case TR:dlo(o->e.k);dlo(o->e.v);BK;
    }if(!rcy(&ofl,o))DL(o);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x4, %rax
ja 0x3266
movq -0x10(%rbp), %rax
leaq 0x7e21(%rip), %rcx      # 0xb018
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
jmp 0x3266
jmp 0x3211
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2a60
cmpq $0x0, %rax
je 0x323b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2920
movq %rax, %rdi
callq 0x31d0
jmp 0x3211
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2a80
jmp 0x3266
jmp 0x3266
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31d0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x31d0
movq -0x8(%rbp), %rsi
leaq 0xc5bf(%rip), %rdi      # 0xf830
callq 0x24f0
cmpl $0x0, %eax
jne 0x3284
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phase[P]o/o.c
// Function: dup
O dup(O o){
    L z;S s;switch(o->t){
    case TCB:R newocb(o->s.s,o->s.z);BK;
    case TS:R newos(o->s.s,o->s.z);BK;
    case TD:R newod(o->d);BK;
    case TA:R dupa(o);BK;
    case TR:R newoe(dup(o->e.k),dup(o->e.v));BK;
    }R 0; //appease the compiler
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x4, %rax
ja 0x341d
movq -0x28(%rbp), %rax
leaq 0x7ca1(%rip), %rcx      # 0xb02c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x2f10
movq %rax, -0x8(%rbp)
jmp 0x3425
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x2fe0
movq %rax, -0x8(%rbp)
jmp 0x3425
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x2ed0
movq %rax, -0x8(%rbp)
jmp 0x3425
movq -0x10(%rbp), %rdi
callq 0x32d0
movq %rax, -0x8(%rbp)
jmp 0x3425
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3360
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3360
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x3180
movq %rax, -0x8(%rbp)
jmp 0x3425
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/phase[P]o/o.c
// Function: eqo
I eqo(O a,O b){
    if(a->t!=b->t)R 0;
    switch(a->t){
    case TS:case TCB:R a->s.z!=b->s.z?0:memcmp(a->s.s,b->s.s,a->s.z)==0;
    case TD:R a->d==b->d;
    case TR:R eqo(a->e.k,b->e.k)&&eqo(a->e.v,b->e.v);
    default:ex("non-TS-TD in eqo");R 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x34aa
movl $0x0, -0x4(%rbp)
jmp 0x35a4
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x4, %rax
ja 0x3591
movq -0x20(%rbp), %rax
leaq 0x7b77(%rip), %rcx      # 0xb040
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x34eb
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x3516
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x2150
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x35a4
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x35a4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3480
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x25(%rbp)
je 0x3584
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3480
cmpl $0x0, %eax
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x35a4
leaq 0x7e87(%rip), %rdi      # 0xb41f
callq 0x23e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phase[P]o/o.c
// Function: truth
I truth(O o){
    switch(o->t){
    case TD:R o->d!=0;BK;
    case TS:R o->s.z!=0;BK;
    case TA:R len(o->a)!=0;BK;
    case TCB:{O t;I r;excb(o);t=pop(top(rst));r=truth(t);dlo(t);R r;}
    case TR:R truth(o->e.k)&&truth(o->e.v);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x4, %rax
ja 0x36b8
movq -0x28(%rbp), %rax
leaq 0x7a79(%rip), %rcx      # 0xb054
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x36b8
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x36b8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2a60
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x36b8
movq -0x10(%rbp), %rdi
callq 0x36d0
movq 0xc1d8(%rip), %rdi      # 0xf828
callq 0x2970
movq %rax, %rdi
callq 0x2920
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x35b0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31d0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x36b8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x35b0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x36ad
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x35b0
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phase[P]o/o.c
// Function: eq
V eq(ST s){O a,b;b=pop(s);a=pop(s);
    if(b->t==TA){I i,w=0;if(a->t!=TR)a=newoe(a,pop(s));for(i=0;i<len(b->a);++i){O e=b->a->st[i];if(e->t!=TR)TE;if(eqo(e->e.k,a->e.k)){dlo(e);b->a->st[i]=a;w=1;BK;}}if(!w)psh(b->a,a);psh(s,b);} //set
    else if(a->t!=TA){psh(s,newod(eqo(a,b)));dlo(a);dlo(b);} //equal
    else TE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2920
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2920
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x4a11
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x4, (%rax)
je 0x4944
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2920
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x3180
movq %rax, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2a60
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x49eb
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x4, (%rax)
je 0x4998
leaq 0x6a9d(%rip), %rdi      # 0xb430
callq 0x23e0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3480
cmpl $0x0, %eax
je 0x49db
movq -0x28(%rbp), %rdi
callq 0x31d0
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x1, -0x20(%rbp)
jmp 0x49eb
jmp 0x49dd
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x494b
cmpl $0x0, -0x20(%rbp)
jne 0x4a02
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x28c0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x28c0
jmp 0x4a66
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
je 0x4a58
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3480
cvtsi2sd %eax, %xmm0
callq 0x2ed0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x28c0
movq -0x10(%rbp), %rdi
callq 0x31d0
movq -0x18(%rbp), %rdi
callq 0x31d0
jmp 0x4a64
leaq 0x69d1(%rip), %rdi      # 0xb430
callq 0x23e0
jmp 0x4a66
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)