LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/wjmelements[P]evm/src/evm.c
// Function: evmRevertStorageChanges
static void evmRevertStorageChanges(account_t *account, storageChanges_t **changes) {
    if (*changes == NULL) {
        return;
    }
    storage_t *storage = getAccountStorage(account, &(*changes)->key);
    assert(equal256(&storage->value, &(*changes)->after));
    copy256(&storage->value, &(*changes)->before);
    storage->warm = (*changes)->warm;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rsi
testq %rsi, %rsi
je 0xc7a9
movq %rdi, %r14
callq 0x867f
movq %rax, %r15
leaq 0x20(%rax), %r12
movq (%rbx), %rsi
addq $0x40, %rsi
movq %r12, %rdi
callq 0xd232
testb %al, %al
je 0xc7b5
movq (%rbx), %rsi
addq $0x20, %rsi
movq %r12, %rdi
callq 0xc9b5
movq (%rbx), %rsi
movq 0x60(%rsi), %rax
movq %rax, 0x60(%r15)
addq $0x68, %rsi
movq %r14, %rdi
callq 0xc73f
movq (%rbx), %rdi
callq 0x3040
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x6467(%rip), %rdi      # 0x12c23
leaq 0x6410(%rip), %rsi      # 0x12bd3
leaq 0x6487(%rip), %rcx      # 0x12c51
movl $0x611, %edx            # imm = 0x611
callq 0x3120
// File: /workspace/github_c_makefile_star2_O1/wjmelements[P]evm/src/evm.c
// Function: evmRevertLogChanges
static void evmRevertLogChanges(logChanges_t **changes) {
    if (*changes == NULL) {
        return;
    }
    evmRevertLogChanges(&(*changes)->prev);

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

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

// Assembly:
movl $0xffffffff, 0x2049fb6(%rip) # imm = 0xFFFFFFFF
movb $0x0, 0x2049fb3(%rip)   # 0x2059e24
movl $0x1, 0x2049fad(%rip)   # 0x2059e28
movq $0x0, 0x2049faa(%rip) # 0x2059e30
leaq 0x2049fa3(%rip), %rax   # 0x2059e30
movq %rax, 0x204f7ac(%rip)   # 0x205f640
retq
// File: /workspace/github_c_makefile_star2_O1/wjmelements[P]evm/src/scan.c
// Function: parseConstant
op_t parseConstant(const char **iter) {
    if (isHexConstantPrefix(*iter)) {
        *iter += 2;
        return parseHex(iter);
    } else {
        int negative = 0;
        while (parseNegative(iter)) {
            negative = !negative;
        }
        return parseDecimal(iter, negative);
    }
}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r15
movb (%r15), %al
leal -0x3a(%rax), %ecx
cmpb $-0xb, %cl
ja 0x100cb
andb $-0x21, %al
addb $-0x47, %al
movq %r15, %r12
cmpb $-0x6, %al
jb 0x100ec
leaq 0x1(%r15), %r12
movq %r12, (%rdi)
movb (%r12), %al
leal -0x3a(%rax), %ecx
incq %r12
cmpb $-0xb, %cl
ja 0x100cf
andb $-0x21, %al
addb $-0x47, %al
cmpb $-0x6, %al
jae 0x100cf
decq %r12
xorl %ebx, %ebx
cmpq %r15, %r12
jbe 0x1021d
movq 0x8efa(%rip), %rdx      # 0x18ff8
leaq 0x20a6(%rip), %r14      # 0x121ab
leaq 0x204f544(%rip), %rbp   # 0x205f650
movq %r12, %rax
subq %r15, %rax
cmpq $0x2, %rax
jl 0x10134
movzbl -0x2(%r12), %ecx
leal -0x30(%rcx), %r13d
cmpb $0xa, %r13b
jb 0x10160
leal -0x61(%rcx), %eax
cmpb $0x5, %al
ja 0x10153
addb $-0x57, %cl
jmp 0x1015d
movzbl -0x1(%r12), %ecx
decq %r12
leal -0x30(%rcx), %r13d
cmpb $0xa, %r13b
jb 0x1019f
leal -0x61(%rcx), %eax
cmpb $0x5, %al
ja 0x10179
addb $-0x57, %cl
jmp 0x10183
leal -0x41(%rcx), %eax
cmpb $0x5, %al
ja 0x101c0
addb $-0x37, %cl
movl %ecx, %r13d
movzbl -0x1(%r12), %ecx
leal -0x30(%rcx), %eax
cmpb $0xa, %al
jb 0x10194
leal -0x61(%rcx), %eax
cmpb $0x5, %al
ja 0x10188
addb $-0x57, %cl
jmp 0x10192
leal -0x41(%rcx), %eax
cmpb $0x5, %al
ja 0x101da
addb $-0x37, %cl
movl %ecx, %r13d
jmp 0x1019f
leal -0x41(%rcx), %eax
cmpb $0x5, %al
ja 0x101fa
addb $-0x37, %cl
movl %ecx, %eax
addq $-0x2, %r12
shlb $0x4, %r13b
addb %al, %r13b
movzbl 0x2049c86(%rip), %eax   # 0x2059e2c
leal 0x1(%rax), %ecx
movb %cl, 0x2049c7d(%rip)    # 0x2059e2c
movb %r13b, (%rax,%rbp)
incb %bl
cmpq %r15, %r12
ja 0x1010c
jmp 0x1021d
movq (%rdx), %rdi
movq %r14, %rsi
movq %rdx, %r13
movl %ecx, %edx
xorl %eax, %eax
callq 0x31d0
movq %r13, %rdx
movb $-0x1, %r13b
jmp 0x10160
movq (%rdx), %rdi
movq %r14, %rsi
movq %r14, %r13
movq %rdx, %r14
movl %ecx, %edx
xorl %eax, %eax
callq 0x31d0
movq %r14, %rdx
movq %r13, %r14
movb $-0x1, %r13b
jmp 0x1019f
movq (%rdx), %rdi
movq %r14, %rsi
movq %rdx, %r14
movl %ecx, %edx
xorl %eax, %eax
callq 0x31d0
movq %r14, %rdx
leaq 0x1f95(%rip), %r14      # 0x121ab
movb $-0x1, %al
jmp 0x10194
cmpb $0x21, %bl
jb 0x1022b
cmpb $0x0, 0x2049bfb(%rip)   # 0x2059e24
je 0x1023f
addb $0x5f, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3f9c(%rip), %rdi      # 0x141e2
leaq 0x3fb2(%rip), %rsi      # 0x141ff
leaq 0x3fb6(%rip), %rcx      # 0x1420a
movl $0x42, %edx
callq 0x3120
// File: /workspace/github_c_makefile_star2_O1/wjmelements[P]evm/src/scan.c
// Function: scanNextOp
op_t scanNextOp(const char **iter) {
    jump_t jump;
    programCounter++;
    jump.programCounter = programCounter;
    if (scanstackEmpty()) {
        scanOp(iter);
    }
    if (scanstackTopLabel(&jump.label)) {
        op_t type = scanstackPop();
        if (type == JUMPDEST) {
            jump.dataSize = 1;
            registerLabel(jump);
            return type;
        } else if (type == CODECOPY) {
            // because we can one data entry at a time, the stack size is the dataSize
            jump.dataSize = scanstackIndex;
            registerLabel(jump);
            return scanstackPop();
        } else if (type == CODESIZE) {
            jump.len = 1;
            labelQueuePush(jump, type);
            return type;
        } else {
            jump.len = 1;
            labelQueuePush(jump, type);
            return type;
        }
    } else return scanstackPop();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl 0x2049bb5(%rip), %eax   # 0x2059e20
incl %eax
movl %eax, 0x2049bad(%rip)   # 0x2059e20
movl %eax, 0x28(%rsp)
cmpb $0x0, 0x2049bae(%rip)   # 0x2059e2c
jne 0x10285
callq 0x10395
movzbl 0x2049ba0(%rip), %ebx   # 0x2059e2c
leaq 0x204f7bd(%rip), %r14   # 0x205fa50
movq (%r14,%rbx,8), %rdi
testq %rdi, %rdi
je 0x10300
movups (%rdi), %xmm0
movups %xmm0, 0x38(%rsp)
callq 0x3040
movq $0x0, (%r14,%rbx,8)
leal -0x1(%rbx), %eax
movb %al, 0x2049b72(%rip)    # 0x2059e2c
movzbl %al, %eax
leaq 0x204f38c(%rip), %r14   # 0x205f650
movzbl (%rax,%r14), %ebx
cmpl $0x38, %ebx
je 0x10317
cmpl $0x39, %ebx
je 0x10359
cmpl $0x5b, %ebx
jne 0x10317
movw $0x1, 0x2c(%rsp)
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x105ad
jmp 0x1038b
decb %bl
movb %bl, 0x2049b24(%rip)    # 0x2059e2c
movzbl %bl, %eax
leaq 0x204f33e(%rip), %rcx   # 0x205f650
movb (%rax,%rcx), %bl
jmp 0x1038b
movb $0x1, 0x2e(%rsp)
movl $0x30, %edi
callq 0x3200
movq 0x204f313(%rip), %rcx   # 0x205f640
movq %rax, (%rcx)
leaq 0x28(%rax), %rcx
movq $0x0, 0x28(%rax)
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movb %bl, 0x20(%rax)
movq %rcx, 0x204f2e9(%rip)   # 0x205f640
jmp 0x1038b
movw %ax, 0x2c(%rsp)
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x105ad
movb 0x2049ab0(%rip), %al    # 0x2059e2c
decb %al
movb %al, 0x2049aa8(%rip)    # 0x2059e2c
movzbl %al, %eax
movb (%rax,%r14), %bl
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/wjmelements[P]evm/src/scan.c
// Function: fprintLabels
void fprintLabels(FILE *stream) {
    fputc('{', stream);
    for (uint32_t i = 0; i < labelCount; i++) {
        if (i) {
            fputc(',', stream);
        }
        fputc('\n', stream);
        fputc('\t', stream);
        fputc('"', stream);
        fprintLabel(stream, labels + i);
        fputc('"', stream);
        fprintf(stream, ": \"0x%04x\"", labelLocations[i]);
    }
    if (labelCount) {
        fputc('\n', stream);
    }
    fputc('}', stream);
    fputc('\n', stream);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x7b, %edi
movq %rbx, %rsi
callq 0x3180
cmpl $0x0, 0x204958b(%rip)   # 0x2059e38
je 0x10974
leaq 0x2049586(%rip), %r15   # 0x2059e40
leaq 0x3916(%rip), %r14      # 0x141d7
xorl %r13d, %r13d
testq %r13, %r13
je 0x108d6
movl $0x2c, %edi
movq %rbx, %rsi
callq 0x3180
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3180
movl $0x9, %edi
movq %rbx, %rsi
callq 0x3180
movl $0x22, %edi
movq %rbx, %rsi
callq 0x3180
movq %r13, %rbp
shlq $0x4, %rbp
cmpq $0x0, 0x8(%rbp,%r15)
je 0x1092c
addq %r15, %rbp
xorl %r12d, %r12d
movq (%rbp), %rax
movsbl (%rax,%r12), %edi
movq %rbx, %rsi
callq 0x3180
incq %r12
cmpq 0x8(%rbp), %r12
jb 0x10912
movl $0x22, %edi
movq %rbx, %rsi
callq 0x3180
leaq 0x204dd00(%rip), %rax   # 0x205e640
movl (%rax,%r13,4), %edx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x31d0
incq %r13
movl 0x20494de(%rip), %eax   # 0x2059e38
cmpq %rax, %r13
jb 0x108c4
testl %eax, %eax
je 0x10974
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3180
movl $0x7d, %edi
movq %rbx, %rsi
callq 0x3180
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3180
// File: /workspace/github_c_makefile_star2_O1/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:
movabsq $0x400b30800000000, %rcx # imm = 0x400B30800000000
movq (%rdi), %rsi
movl 0x2049478(%rip), %r8d   # 0x2059e28
leaq 0x1(%rsi), %rdx
movzbl (%rsi), %eax
xorl %r9d, %r9d
cmpq $0x3a, %rax
ja 0x109e8
btq %rax, %rcx
jae 0x109e8
testb %al, %al
je 0x10a22
testb %r9b, %r9b
je 0x10a22
cmpb $0xa, %al
jne 0x109dd
incl %r8d
movl %r8d, 0x204944b(%rip)   # 0x2059e28
incq %rsi
movq %rsi, (%rdi)
incq %rdx
jmp 0x109b4
cmpl $0x7b, %eax
je 0x109c6
cmpl $0x7d, %eax
je 0x109c6
leal -0x3a(%rax), %r9d
cmpb $-0xa, %r9b
setae %r9b
leal -0x5b(%rax), %r10d
cmpb $-0x1a, %r10b
setae %r10b
orb %r9b, %r10b
jne 0x10a1d
leal -0x7b(%rax), %r9d
cmpb $-0x1a, %r9b
setb %r9b
jmp 0x109c6
xorl %r9d, %r9d
jmp 0x109c6
cmpb $0x2f, %al
jne 0x10a40
movq %rdx, (%rdi)
cmpb $0xa, (%rdx)
leaq 0x1(%rdx), %rdx
jne 0x10a26
incl 0x20493f0(%rip)         # 0x2059e28
movq %rdx, (%rdi)
jmp 0x109a6
retq
// File: /workspace/github_c_makefile_star2_O1/wjmelements[P]evm/src/scan.c
// Function: scanLabel
static void scanLabel(const char **iter) {
    const char *start = *iter;
    for (char ch; isLowerCase(**iter); (*iter)++);
    const char *end = *iter;
    char next = scanWaste(iter);
    if (next == ':') {
        (*iter)++;
        scanstackPushLabel(start, end - start, JUMPDEST);
    } else {
        scanstackPushLabel(start, end - start, STOP);
        scanstackPush(PUSH1);
    }
    scanWaste(iter);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movb (%r14), %al
addb $-0x7b, %al
movq %r14, %r15
cmpb $-0x1a, %al
jb 0x10a6e
leaq 0x1(%r14), %r15
movq %r15, (%rbx)
movb (%r15), %al
addb $-0x7b, %al
incq %r15
cmpb $-0x1a, %al
jae 0x10a5c
decq %r15
movq %rbx, %rdi
callq 0x1099c
cmpb $0x3a, %al
jne 0x10abc
incq (%rbx)
subq %r14, %r15
movl $0x10, %edi
callq 0x3200
movq %r14, (%rax)
movq %r15, 0x8(%rax)
movzbl 0x2049394(%rip), %ecx   # 0x2059e2c
leal 0x1(%rcx), %edx
movb %dl, 0x204938b(%rip)    # 0x2059e2c
leaq 0x204eba8(%rip), %rsi   # 0x205f650
movb $0x5b, (%rcx,%rsi)
movzbl %dl, %ecx
leaq 0x204ef9a(%rip), %rdx   # 0x205fa50
movq %rax, (%rdx,%rcx,8)
jmp 0x10b00
subq %r14, %r15
movl $0x10, %edi
callq 0x3200
movq %r14, (%rax)
movq %r15, 0x8(%rax)
movzbl 0x2049355(%rip), %ecx   # 0x2059e2c
leal 0x1(%rcx), %edx
leaq 0x204eb6f(%rip), %rsi   # 0x205f650
movb $0x0, (%rcx,%rsi)
movzbl %dl, %edx
leaq 0x204ef61(%rip), %rdi   # 0x205fa50
movq %rax, (%rdi,%rdx,8)
leal 0x2(%rcx), %eax
movb %al, 0x2049330(%rip)    # 0x2059e2c
movb $0x60, (%rdx,%rsi)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1099c
// File: /workspace/github_c_makefile_star2_O1/wjmelements[P]evm/src/scan.c
// Function: scanDataSection
static void scanDataSection(const char **iter) {
    (*iter)++; // '{' or ','
    inDataSection = true;
    scanWaste(iter);

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
incq (%rdi)
movb $0x1, 0x2049305(%rip)   # 0x2059e24
callq 0x1099c
movq (%rbx), %r14
movb (%r14), %al
leal -0x7b(%rax), %ecx
cmpb $-0x1a, %cl
jb 0x10c05
movq (%rbx), %r15
movb (%r15), %al
addb $-0x7b, %al
cmpb $-0x1a, %al
jb 0x10b57
incq %r15
movq %r15, (%rbx)
movb (%r15), %al
addb $-0x7b, %al
incq %r15
cmpb $-0x1a, %al
jae 0x10b45
decq %r15
movq %rbx, %rdi
callq 0x1099c
cmpb $0x3a, %al
jne 0x10c0d
incq (%rbx)
movq %rbx, %rdi
callq 0x1099c
movq (%rbx), %rax
cmpb $0x22, (%rax)
je 0x10b90
cmpw $0x7830, (%rax)         # imm = 0x7830
jne 0x10b90
addq $0x2, %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x100a7
subq %r14, %r15
movl $0x10, %edi
callq 0x3200
movq %r14, (%rax)
movq %r15, 0x8(%rax)
movzbl 0x2049281(%rip), %ecx   # 0x2059e2c
leal 0x1(%rcx), %edx
movb %dl, 0x2049278(%rip)    # 0x2059e2c
leaq 0x204ea95(%rip), %rsi   # 0x205f650
movb $0x39, (%rcx,%rsi)
movzbl %dl, %ecx
leaq 0x204ee87(%rip), %rdx   # 0x205fa50
movq %rax, (%rdx,%rcx,8)
movq %rbx, %rdi
callq 0x1099c
movq (%rbx), %rax
movzbl (%rax), %ecx
cmpl $0x2c, %ecx
je 0x10bff
cmpl $0x7d, %ecx
jne 0x10c15
movb $0x0, 0x2049238(%rip)   # 0x2059e24
incq %rax
movq %rax, (%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1099c
popq %rbx
popq %r14
popq %r15
retq
movzbl %al, %edi
callq 0x42b9
movzbl %al, %edi
callq 0x4263
movzbl %cl, %edi
callq 0x428e
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
incq (%rdi)
callq 0x1099c
movq (%rbx), %r14
movb (%r14), %al
leal -0x7b(%rax), %ecx
cmpb $-0x1b, %cl
jbe 0x10cad
movq (%rbx), %r15
movb (%r15), %al
addb $-0x7b, %al
cmpb $-0x1a, %al
jb 0x10c5c
incq %r15
movq %r15, (%rbx)
movb (%r15), %al
addb $-0x7b, %al
incq %r15
cmpb $-0x1a, %al
jae 0x10c4a
decq %r15
subq %r14, %r15
movl $0x10, %edi
callq 0x3200
movq %r14, (%rax)
movq %r15, 0x8(%rax)
movzbl 0x20491b5(%rip), %ecx   # 0x2059e2c
leal 0x1(%rcx), %edx
leaq 0x204e9cf(%rip), %rsi   # 0x205f650
movb $0x38, (%rcx,%rsi)
movzbl %dl, %edx
leaq 0x204edc1(%rip), %rdi   # 0x205fa50
movq %rax, (%rdi,%rdx,8)
leal 0x2(%rcx), %eax
movb %al, 0x2049190(%rip)    # 0x2059e2c
movb $0x60, (%rdx,%rsi)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1099c
movzbl %al, %edi
callq 0x42e7
jmp 0x10c3b
// File: /workspace/github_c_makefile_star2_O1/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 %rax
movq (%rdi), %rcx
movb (%rcx), %r8b
cmpb %sil, %r8b
je 0x10d27
movl 0x204915f(%rip), %edx   # 0x2059e28
incq %rcx
movabsq $0x400b30800000000, %r9 # imm = 0x400B30800000000
movzbl %r8b, %eax
cmpb $0x3a, %al
ja 0x10cf4
cmpq $0xa, %rax
jne 0x10cee
incl %edx
movl %edx, 0x204913c(%rip)   # 0x2059e28
jmp 0x10cfe
btq %rax, %r9
jb 0x10d2f
cmpl $0x7b, %eax
je 0x10d2f
cmpl $0x7d, %eax
je 0x10d2f
leal -0x30(%r8), %r10d
cmpb $0xa, %r10b
jb 0x10d2f
andb $-0x21, %r8b
addb $-0x41, %r8b
cmpb $0x19, %r8b
jbe 0x10d2f
movq %rcx, (%rdi)
movb (%rcx), %r8b
incq %rcx
cmpb %sil, %r8b
jne 0x10cd6
decq %rcx
incq %rcx
movq %rcx, (%rdi)
popq %rax
retq
movzbl %sil, %esi
movl %eax, %edi
callq 0x430c
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl $0x8, %edi
movl $0x1, %esi
callq 0x31b0
movq %rax, %r15
leaq 0x36be(%rip), %rdx      # 0x14483
movl $0x8, %esi
movq %rax, %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x3110
cltq
movq %rax, (%r14)
movq %r15, 0x8(%r14)
movq $0x8, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq (%rdi), %rax
movb (%rax), %cl
testb %cl, %cl
je 0x11594
incq %rax
leal -0x3a(%rcx), %edx
cmpb $-0xb, %dl
ja 0x11582
movl %ecx, %edx
andb $-0x21, %dl
addb $-0x47, %dl
cmpb $-0x7, %dl
ja 0x11582
movq %rax, (%rdi)
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0x1155f
jmp 0x11594
cmpb $0x30, %cl
jne 0x11594
cmpb $0x78, (%rax)
jne 0x11594
incq %rax
movq %rax, (%rdi)
jmp 0x11553
retq
// File: /workspace/github_c_makefile_star2_O1/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:
leal (%rsi,%rsi,4), %eax
leal (%rsi,%rsi,4), %esi
addl $0x7, %esi
testl %eax, %eax
cmovnsl %eax, %esi
movl %esi, %ecx
sarl $0x3, %ecx
movslq %ecx, %rdx
movzbl (%rdi,%rdx), %ecx
shll $0x8, %ecx
andl $-0x8, %esi
subl %esi, %eax
cmpl $0x4, %eax
jl 0x2f0a
movzbl 0x1(%rdi,%rdx), %edx
orl %edx, %ecx
shlxl %eax, %ecx, %eax
shrl $0xb, %eax
andb $0x1f, %al
retq
// File: /workspace/github_c_makefile_star2_O1/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:
shll $0x3, %esi
movslq %esi, %rax
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
addl %edx, %ecx
movslq %ecx, %rdx
movzbl (%rdi,%rdx), %esi
shll $0xa, %esi
movzbl 0x1(%rdi,%rdx), %ecx
shll $0x5, %ecx
orl %esi, %ecx
leal (%rdx,%rdx,4), %esi
subl %esi, %eax
cmpl $0x3, %eax
jl 0x2f54
movzbl 0x2(%rdi,%rdx), %edx
orl %edx, %ecx
shlxl %eax, %ecx, %eax
shrl $0x7, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1192(%rip), %r14      # 0x41b6
xorl %r15d, %r15d
xorl %r12d, %r12d
movzbl (%rbx,%r12), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2030
incq %r12
cmpq $0x8, %r12
jne 0x302a
movl $0xa, %edi
callq 0x2080
incq %r15
addq $0x8, %rbx
cmpq $0x5, %r15
jne 0x3027
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1145(%rip), %r14      # 0x41bc
xorl %r15d, %r15d
xorl %r12d, %r12d
movzbl (%rbx,%r12), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2030
incq %r12
cmpq $0x8, %r12
jne 0x307d
movl $0xa, %edi
callq 0x2080
incq %r15
addq $0x8, %rbx
cmpq $0x5, %r15
jne 0x307a
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2080
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
movq 0x2dfd(%rip), %rax      # 0x5fe8
xorl %ecx, %ecx
vpmovsxbd 0xf8e(%rip), %ymm0 # 0x4184
vpbroadcastd 0xf81(%rip), %ymm1 # 0x4180
vpaddd (%rax){1to8}, %ymm0, %ymm2
vpsrad $0x1f, %ymm2, %ymm3
vpsrld $0x1d, %ymm3, %ymm3
vpaddd %ymm3, %ymm2, %ymm3
vpand %ymm1, %ymm3, %ymm3
vpsubd %ymm3, %ymm2, %ymm2
vpbroadcastd %ecx, %ymm3
vpaddd %ymm3, %ymm2, %ymm2
vextracti128 $0x1, %ymm2, %xmm3
vpmovsxdq %xmm3, %ymm3
vpmovsxdq %xmm2, %ymm2
vmovq %xmm2, %rdx
vpextrq $0x1, %xmm2, %rsi
vextracti128 $0x1, %ymm2, %xmm2
vpextrq $0x1, %xmm2, %r8
vmovq %xmm2, %r9
vmovq %xmm3, %r10
vpextrq $0x1, %xmm3, %r11
vextracti128 $0x1, %ymm3, %xmm2
vmovq %xmm2, %rbx
vpextrq $0x1, %xmm2, %r14
movzbl (%rdi,%rdx), %edx
vmovd %edx, %xmm2
vpinsrb $0x1, (%rdi,%rsi), %xmm2, %xmm2
vpinsrb $0x2, (%rdi,%r9), %xmm2, %xmm2
vpinsrb $0x3, (%rdi,%r8), %xmm2, %xmm2
vpinsrb $0x4, (%rdi,%r10), %xmm2, %xmm2
vpinsrb $0x5, (%rdi,%r11), %xmm2, %xmm2
vpinsrb $0x6, (%rdi,%rbx), %xmm2, %xmm2
vpinsrb $0x7, (%rdi,%r14), %xmm2, %xmm2
vmovq %xmm2, -0x28(%rsp,%rcx)
addq $0x8, %rcx
addq $0x4, %rax
cmpq $0x28, %rcx
jne 0x31ff
movq -0x8(%rsp), %rax
movq %rax, 0x20(%rdi)
vmovups -0x28(%rsp), %ymm0
vmovups %ymm0, (%rdi)
popq %rbx
popq %r14
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
movq 0x2d06(%rip), %rax      # 0x5fe8
xorl %ecx, %ecx
vpmovsxbd 0xe9f(%rip), %ymm0 # 0x418c
vpbroadcastd 0xe8a(%rip), %ymm1 # 0x4180
vpsubd (%rax){1to8}, %ymm0, %ymm2
vpsrad $0x1f, %ymm2, %ymm3
vpsrld $0x1d, %ymm3, %ymm3
vpaddd %ymm3, %ymm2, %ymm3
vpand %ymm1, %ymm3, %ymm3
vpsubd %ymm3, %ymm2, %ymm2
vpbroadcastd %ecx, %ymm3
vpaddd %ymm3, %ymm2, %ymm2
vextracti128 $0x1, %ymm2, %xmm3
vpmovsxdq %xmm3, %ymm3
vpmovsxdq %xmm2, %ymm2
vmovq %xmm2, %rdx
vpextrq $0x1, %xmm2, %rsi
vextracti128 $0x1, %ymm2, %xmm2
vpextrq $0x1, %xmm2, %r8
vmovq %xmm2, %r9
vmovq %xmm3, %r10
vpextrq $0x1, %xmm3, %r11
vextracti128 $0x1, %ymm3, %xmm2
vmovq %xmm2, %rbx
vpextrq $0x1, %xmm2, %r14
movzbl (%rdi,%rdx), %edx
vmovd %edx, %xmm2
vpinsrb $0x1, (%rdi,%rsi), %xmm2, %xmm2
vpinsrb $0x2, (%rdi,%r9), %xmm2, %xmm2
vpinsrb $0x3, (%rdi,%r8), %xmm2, %xmm2
vpinsrb $0x4, (%rdi,%r10), %xmm2, %xmm2
vpinsrb $0x5, (%rdi,%r11), %xmm2, %xmm2
vpinsrb $0x6, (%rdi,%rbx), %xmm2, %xmm2
vpinsrb $0x7, (%rdi,%r14), %xmm2, %xmm2
vmovq %xmm2, -0x28(%rsp,%rcx)
addq $0x8, %rcx
addq $0x4, %rax
cmpq $0x28, %rcx
jne 0x32f6
movq -0x8(%rsp), %rax
movq %rax, 0x20(%rdi)
vmovups -0x28(%rsp), %ymm0
vmovups %ymm0, (%rdi)
popq %rbx
popq %r14
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x8(%rdi), %rax
xorl %ecx, %ecx
vmovd 0xd5c(%rip), %xmm0      # 0x41a0
movq %rax, %rsi
leaq -0x28(%rsp), %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
movb (%rsi,%r10,8), %dl
movb %dl, (%r8,%r10,8)
leaq 0x1(%r10), %rdx
movq %rdx, %r10
cmpq $0x4, %rdx
jne 0x3452
movb 0x8(%rdi,%r9), %r11b
movb 0x20(%rdi,%r9), %r10b
leal (%r11,%r11), %ebp
andb $0x1e, %bpl
leal (,%r11,8), %ebx
sarb $0x7, %bl
andb $0x5, %bl
xorb %bpl, %bl
leal (,%rbx,8), %r14d
andb $0x18, %r14b
movl %r11d, %ebp
shlb $0x4, %bpl
sarb $0x7, %bpl
andb $0x14, %bpl
shlb $0x5, %r11b
sarb $0x7, %r11b
andb $0xa, %r11b
orb %bpl, %r11b
movzbl 0x10(%rdi,%r9), %r15d
leal (%r15,%r15), %r13d
andb $0x1e, %r13b
movzbl 0x18(%rdi,%r9), %r12d
leal (%r12,%r12), %ebp
andb $0x1e, %bpl
xorb %r14b, %bpl
xorb %r13b, %bpl
leal (%r10,%r10), %r13d
andb $0x1e, %r13b
leal (,%r10,8), %r14d
sarb $0x7, %r14b
andb $0x5, %r14b
xorb %r13b, %r14b
leal (,%r14,8), %r13d
andb $0x18, %r13b
movl %r10d, %edx
shlb $0x4, %dl
sarb $0x7, %dl
andb $0x14, %dl
shlb $0x5, %r10b
sarb $0x7, %r10b
andb $0xa, %r10b
vmovd %r15d, %xmm1
vpinsrb $0x1, %r12d, %xmm1, %xmm1
vpinsrb $0x2, %ebx, %xmm1, %xmm1
orb %dl, %r10b
vpinsrb $0x3, %r14d, %xmm1, %xmm1
vptestmb %xmm0, %xmm1, %k1
vpbroadcastb 0xc71(%rip), %xmm1 {%k1} {z} # 0x41b0
vpsrld $0x10, %xmm1, %xmm2
vpxor %xmm2, %xmm1, %xmm1
vpsrlw $0x8, %xmm1, %xmm2
vpxor %xmm2, %xmm1, %xmm1
xorb (%rdi,%r9), %r10b
vmovd %xmm1, %edx
xorb %r11b, %r14b
xorb %bl, %r14b
xorb %r13b, %r14b
xorb %bpl, %r14b
xorb %r10b, %r14b
xorb %dl, %r14b
movb %r14b, -0x8(%rsp,%r9)
incq %r9
incq %r8
incq %rsi
cmpq $0x8, %r9
jne 0x344f
movq -0x8(%rsp), %rdx
movq %rdx, 0x20(%rdi)
vmovdqu -0x28(%rsp), %ymm1
vmovdqu %ymm1, (%rdi)
incl %ecx
cmpl $0x5, %ecx
jne 0x3444
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %rbx
xorl %eax, %eax
leaq -0x20(%rsp), %rcx
vpbroadcastb 0xbf0(%rip), %xmm0 # 0x41b1
vpbroadcastb 0xbe9(%rip), %xmm1 # 0x41b3
vpbroadcastb 0xbe1(%rip), %xmm2 # 0x41b4
vmovd 0xbc5(%rip), %xmm3      # 0x41a0
movq %rcx, %rdx
movq %rdi, %rsi
xorl %r8d, %r8d
movzbl (%rdi,%r8), %r11d
leal (%r11,%r11), %r10d
andb $0x1e, %r10b
leal (,%r11,8), %r9d
sarb $0x7, %r9b
andb $0x5, %r9b
xorb %r10b, %r9b
movzbl 0x18(%rdi,%r8), %ebx
leal (%rbx,%rbx), %ebp
andb $0x1e, %bpl
leal (,%rbx,8), %r10d
sarb $0x7, %r10b
andb $0x5, %r10b
xorb %bpl, %r10b
vmovd %r11d, %xmm4
vpinsrb $0x1, %ebx, %xmm4, %xmm4
vptestmb %xmm0, %xmm4, %k1
vpbroadcastb 0xb73(%rip), %xmm5 {%k1} {z} # 0x41b2
vptestnmb %xmm1, %xmm4, %k1
vpor %xmm2, %xmm5, %xmm4
movzbl 0x10(%rdi,%r8), %r11d
movzbl 0x8(%rdi,%r8), %ebx
vmovd %ebx, %xmm6
vpinsrb $0x1, %r11d, %xmm6, %xmm6
vmovdqu8 %xmm5, %xmm4 {%k1}
vpinsrb $0x2, %r9d, %xmm6, %xmm5
vpinsrb $0x3, %r10d, %xmm5, %xmm5
vptestmb %xmm3, %xmm5, %k1
vpbroadcastb 0xb34(%rip), %xmm5 {%k1} {z} # 0x41b5
xorl %ebx, %r11d
addb %r11b, %r11b
andb $0x1e, %r11b
vpsrld $0x10, %xmm5, %xmm6
vpxor %xmm6, %xmm5, %xmm5
vpsrlw $0x8, %xmm5, %xmm6
vpxor %xmm6, %xmm5, %xmm5
vmovd %xmm5, %ebx
xorb %r9b, %r10b
leal (,%r10,8), %r9d
andb $0x18, %r9b
xorb %r11b, %r9b
vpsrlw $0x8, %xmm4, %xmm5
vpxor %xmm5, %xmm4, %xmm4
vmovd %xmm4, %r11d
xorb %r10b, %r11b
xorb %r9b, %r11b
xorb %bl, %r11b
xorb 0x20(%rdi,%r8), %r11b
movb %r11b, -0x28(%rsp,%r8)
xorl %r9d, %r9d
movb (%rsi,%r9,8), %r10b
movb %r10b, (%rdx,%r9,8)
incq %r9
cmpq $0x4, %r9
jne 0x36d7
incq %r8
incq %rsi
incq %rdx
cmpq $0x8, %r8
jne 0x35e4
movq -0x8(%rsp), %rdx
movq %rdx, 0x20(%rdi)
vmovdqu -0x28(%rsp), %ymm4
vmovdqu %ymm4, (%rdi)
incl %eax
cmpl $0x5, %eax
jne 0x35db
popq %rbx
popq %rbp
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: primate(unsigned char*)
void primate(unsigned char *state) //One round Primate permutation without constant addition 
{
	
	//SubElements
	SubElements(state);	
	//printf("\nState after SubElements:\n"); PrintElementsStateDec(state);

	//ShiftRows
	ShiftRows(state);
	//printf("\nState after ShiftRows:\n"); PrintElementsStateDec(state);

	//MixColumns
	MixColumns(state);
	//printf("\nState after Mixcolumn:\n"); PrintElementsStateDec(state);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
movq 0x28cc(%rip), %rcx      # 0x5ff8
movzbl (%rbx,%rax), %edx
movb (%rcx,%rdx), %dl
movb %dl, (%rbx,%rax)
incq %rax
cmpq $0x28, %rax
jne 0x372c
movq %rbx, %rdi
callq 0x2050
movq %rbx, %rdi
popq %rbx
jmp 0x20d0
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/primatesv1ape80/ref/primate.cpp
// Function: primateInv(unsigned char*)
void primateInv(unsigned char *state) //One round Primate permutation without constant addition 
{
	//MixColumnsInv
	MixColumnsInv(state);
	//printf("\nState after MixcolumnInv:\n"); PrintElementsStateDec(state);

	//SubElementsInv
	SubElementsInv(state);	
	//printf("\nState after SubElementsInv:\n"); PrintElementsStateDec(state);

	//ShiftRowsInv
	ShiftRowsInv(state);
	//printf("\nState after ShiftRowsInv:\n"); PrintElementsStateDec(state);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2150
xorl %eax, %eax
movq 0x288e(%rip), %rcx      # 0x5ff0
movzbl (%rbx,%rax), %edx
movb (%rcx,%rdx), %dl
movb %dl, (%rbx,%rax)
incq %rax
cmpq $0x28, %rax
jne 0x3762
movq %rbx, %rdi
popq %rbx
jmp 0x2120
// File: /workspace/github_c_makefile_star2_O1/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 0x2843(%rip), %rax      # 0x5fc8
movb $0x1, (%rax)
movl $0x1, %ecx
movb $0x1, %dl
leal (%rdx,%rdx), %esi
movl %edx, %edi
shrb %dil
andb $0x1, %dil
shrb $0x4, %dl
andb $0x1, %dl
andb $0x1e, %sil
orb %dil, %sil
xorb %dl, %sil
movb %sil, (%rax,%rcx)
incq %rcx
movl %esi, %edx
cmpq $0xc, %rcx
jne 0x378f
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2140
movq $0x0, (%r14)
xorl %eax, %eax
movb (%rbx,%rax), %cl
movb %cl, 0x8(%r14,%rax)
incq %rax
cmpq $0x20, %rax
jne 0x37d3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0x2ef9
leaq 0x616e(%rip), %rcx      # 0x9018
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rbx), %rdi
callq 0x2030
jmp 0x2ef9
movq (%rdi), %rcx
leaq -0x1(%rax), %rdx
movq %rdx, 0x8(%rdi)
movq -0x8(%rcx,%rax,8), %rdi
callq 0x2e91
movq 0x8(%rbx), %rdi
movq 0x8(%rdi), %rax
testq %rax, %rax
jne 0x2ebe
callq 0x2905
jmp 0x2ef9
movq 0x8(%rbx), %rdi
callq 0x2e91
movq 0x10(%rbx), %rdi
callq 0x2e91
movq 0xa940(%rip), %rax      # 0xd840
movq %rax, %rcx
subq 0xa92e(%rip), %rcx      # 0xd838
cmpq $0x7ff, %rcx            # imm = 0x7FF
jbe 0x2f21
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2030
movq 0xa908(%rip), %rcx      # 0xd830
leaq 0x1(%rax), %rdx
movq %rdx, 0xa90d(%rip)      # 0xd840
andl $0x7ff, %eax            # imm = 0x7FF
movq %rbx, (%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl (%rdi), %eax
cmpq $0x4, %rax
ja 0x30a5
movq %rdi, %rbx
leaq 0x6014(%rip), %rcx      # 0x9028
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd 0x8(%rbx), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x2c39
movl $0x0, (%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0x30a7
movq 0x8(%rbx), %rdi
callq 0x2ff3
movq %rax, %r14
movq 0x10(%rbx), %rdi
callq 0x2ff3
movq %rax, %rbx
callq 0x2c39
movl $0x4, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
jmp 0x30a7
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x2f78
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x2ccc
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x2d55
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movl (%r14), %eax
xorl %ebx, %ebx
cmpl (%r15), %eax
jne 0x3147
cmpl $0x4, %eax
jne 0x3104
movq 0x8(%r14), %rdi
movq 0x8(%r15), %rsi
callq 0x30ca
testl %eax, %eax
je 0x3147
movq 0x10(%r14), %r14
movq 0x10(%r15), %r15
jmp 0x30da
testl %eax, %eax
je 0x3132
cmpl $0x3, %eax
je 0x3112
cmpl $0x1, %eax
jne 0x3154
movq 0x10(%r14), %rdx
cmpq 0x10(%r15), %rdx
jne 0x3147
movq 0x8(%r14), %rdi
movq 0x8(%r15), %rsi
callq 0x21d0
xorl %ebx, %ebx
testl %eax, %eax
sete %bl
jmp 0x3147
movsd 0x8(%r15), %xmm0
cmpeqsd 0x8(%r14), %xmm0
movq %xmm0, %rbx
andl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x61ec(%rip), %rdi      # 0x9347
callq 0x23bc
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl (%rdi), %eax
cmpq $0x4, %rax
ja 0x3225
movq %rdi, %rbx
leaq 0x5ebf(%rip), %rcx      # 0x903c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorpd %xmm0, %xmm0
cmpneqsd 0x8(%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x3229
movq 0x8(%rbx), %rdi
callq 0x3160
testl %eax, %eax
je 0x3227
movq 0x10(%rbx), %rdi
callq 0x3160
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jmp 0x3220
movq 0x8(%rbx), %rcx
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
jmp 0x3220
movq %rbx, %rdi
callq 0x323a
movq 0xa651(%rip), %rax      # 0xd828
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x322e
movq (%rax), %rax
movq -0x8(%rax,%rcx,8), %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x322e
movq (%rax), %rdx
leaq -0x1(%rcx), %rsi
movq %rsi, 0x8(%rax)
movq -0x8(%rdx,%rcx,8), %rbx
movq %rbx, %rdi
callq 0x3160
movl %eax, %r14d
movq %rbx, %rdi
callq 0x2e91
movl %r14d, %eax
jmp 0x3229
xorl %eax, %eax
cmpq $0x0, 0x10(%rbx)
setne %al
jmp 0x3229
jmp 0x3229
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6420(%rip), %rdi      # 0x9655
callq 0x23bc
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x4414
movq %rdi, %r12
movq (%rdi), %rcx
movq %rax, %rdx
decq %rdx
movq %rdx, 0x8(%rdi)
je 0x4414
movq -0x8(%rcx,%rax,8), %r14
leaq -0x2(%rax), %rdx
movq %rdx, 0x8(%r12)
movq -0x10(%rcx,%rax,8), %r15
cmpl $0x2, (%r14)
movl (%r15), %esi
jne 0x439f
cmpl $0x4, %esi
je 0x42d9
testq %rdx, %rdx
je 0x4414
leaq -0x3(%rax), %rdx
movq %rdx, 0x8(%r12)
movq -0x18(%rcx,%rax,8), %rbx
callq 0x2c39
movl $0x4, (%rax)
movq %r15, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rax, %r15
movq 0x8(%r14), %rax
cmpq $0x0, 0x8(%rax)
je 0x434e
movq %r12, -0x38(%rbp)
xorl %ebx, %ebx
movl $0x0, -0x30(%rbp)
movq (%rax), %rax
movq (%rax,%rbx,8), %r12
cmpl $0x4, (%r12)
jne 0x4408
movq 0x8(%r12), %rdi
movq 0x8(%r15), %rsi
callq 0x30ca
movl %eax, %r13d
testl %eax, %eax
je 0x4332
movq %r12, %rdi
callq 0x2e91
movq 0x8(%r14), %rax
movq (%rax), %rax
movq %r15, (%rax,%rbx,8)
movl $0x1, -0x30(%rbp)
testl %r13d, %r13d
jne 0x4344
incq %rbx
movq 0x8(%r14), %rax
cmpq %rbx, 0x8(%rax)
ja 0x42f1
cmpl $0x0, -0x30(%rbp)
movq -0x38(%rbp), %r12
jne 0x436f
movq 0x8(%r14), %rax
movq 0x8(%rax), %rcx
leaq 0x1(%rcx), %rdx
cmpq 0x10(%rax), %rdx
ja 0x4420
movq (%rax), %rsi
movq %rdx, 0x8(%rax)
movq %r15, (%rsi,%rcx,8)
movq 0x8(%r12), %rax
leaq 0x1(%rax), %rcx
cmpq 0x10(%r12), %rcx
ja 0x4420
movq (%r12), %rdx
movq %rcx, 0x8(%r12)
movq %r14, (%rdx,%rax,8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %esi
je 0x4408
movq %r15, %rdi
movq %r14, %rsi
callq 0x30ca
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x2c39
movl $0x0, (%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movq 0x8(%r12), %rcx
leaq 0x1(%rcx), %rdx
cmpq 0x10(%r12), %rdx
ja 0x4420
movq (%r12), %rsi
movq %rdx, 0x8(%r12)
movq %rax, (%rsi,%rcx,8)
movq %r15, %rdi
callq 0x2e91
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2e91
leaq 0x4f49(%rip), %rdi      # 0x9358
callq 0x23bc
leaq 0x523a(%rip), %rdi      # 0x9655
callq 0x23bc
leaq 0x51f8(%rip), %rdi      # 0x961f
callq 0x23bc
// File: /workspace/github_c_makefile_star2_O1/phase[P]o/o.c
// Function: fdo
V fdo(ST s){
    I d;O b=pop(s);O n=pop(s);if(b->t!=TCB)TE;
    if(n->t==TD){O on=v['n'];for(d=0;d<n->d;++d){v['n']=newod(d);excb(b);dlo(v['n']);}dlo(n);dlo(b);v['n']=on;} //for loop
    else if(n->t==TA||n->t==TS){I ts;O on=v['n'];ts=n->t==TS;for(d=0;d<(ts?n->s.z:len(n->a));++d){v['n']=ts?newosc(n->s.s[d]):n->a->st[d];excb(b);if(ts)dlo(v['n']);}v['n']=on;dlo(n);dlo(b);} //for each
    else TE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x61ae
movq (%rdi), %rcx
movq %rax, %rdx
decq %rdx
movq %rdx, 0x8(%rdi)
je 0x61ae
movq -0x8(%rcx,%rax,8), %rbx
leaq -0x2(%rax), %rdx
movq %rdx, 0x8(%rdi)
cmpl $0x3, (%rbx)
jne 0x61ba
movq -0x10(%rcx,%rax,8), %r14
movl (%r14), %r12d
leal -0x1(%r12), %eax
cmpl $0x2, %eax
jae 0x6116
movq 0x7b4a(%rip), %rax      # 0xdbc0
movq %rax, -0x38(%rbp)
leaq 0x10(%r14), %r13
xorl %r15d, %r15d
movq %r13, %rax
cmpl $0x1, %r12d
je 0x6092
movq 0x8(%r14), %rax
addq $0x8, %rax
cmpq %r15, (%rax)
jbe 0x60ed
cmpl $0x1, %r12d
jne 0x60bc
movq 0x8(%r14), %rax
movb (%rax,%r15), %al
movb %al, -0x2a(%rbp)
movb $0x0, -0x29(%rbp)
movl $0x1, %esi
leaq -0x2a(%rbp), %rdi
callq 0x2d55
jmp 0x60c7
movq 0x8(%r14), %rax
movq (%rax), %rax
movq (%rax,%r15,8), %rax
movq %rax, 0x7af2(%rip)      # 0xdbc0
movq %rbx, %rdi
callq 0x323a
cmpl $0x1, %r12d
jne 0x60e8
movq 0x7add(%rip), %rdi      # 0xdbc0
callq 0x2e91
incq %r15
jmp 0x6081
movq -0x38(%rbp), %rax
movq %rax, 0x7ac8(%rip)      # 0xdbc0
movq %r14, %rdi
callq 0x2e91
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2e91
testl %r12d, %r12d
jne 0x61ba
movq 0x7a9a(%rip), %r15      # 0xdbc0
movsd 0x8(%r14), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x6188
movl $0x1, %r12d
movsd %xmm1, -0x38(%rbp)
callq 0x2c39
movl $0x0, (%rax)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movq %rax, 0x7a63(%rip)      # 0xdbc0
movq %rbx, %rdi
callq 0x323a
movq 0x7a54(%rip), %rdi      # 0xdbc0
callq 0x2e91
xorps %xmm1, %xmm1
cvtsi2sd %r12d, %xmm1
movsd 0x8(%r14), %xmm0
incl %r12d
ucomisd %xmm1, %xmm0
ja 0x613c
movq %r14, %rdi
callq 0x2e91
movq %rbx, %rdi
callq 0x2e91
movq %r15, 0x7a21(%rip)      # 0xdbc0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x34a0(%rip), %rdi      # 0x9655
callq 0x23bc
leaq 0x3197(%rip), %rdi      # 0x9358
callq 0x23bc
// File: /workspace/github_c_makefile_star2_O1/phase[P]o/o.c
// Function: toca
V toca(ST st,O o){
    if(o->t==TS){ST ca=newst();I p=0;for(;p<o->s.z;++p)psh(ca,newosc(o->s.s[p]));psh(st,newoa(ca));dlo(o);}
    else if(o->t==TA){msrt(dfsrt,0,st,o->a);psh(st,o);}
    else if(o->t==TCB){O a=pop(st);if(a->t!=TA)TE;msrt(cbsrt,o,st,a->a);psh(st,a);}
    else TE;}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0x3, %eax
je 0x6707
cmpl $0x2, %eax
je 0x66d7
cmpl $0x1, %eax
jne 0x6770
callq 0x269a
movq %rax, %r15
cmpq $0x0, 0x10(%r14)
je 0x6695
xorl %r13d, %r13d
leaq -0x2a(%rbp), %r12
movq 0x8(%r14), %rax
movb (%rax,%r13), %al
movb %al, -0x2a(%rbp)
movb $0x0, -0x29(%rbp)
movl $0x1, %esi
movq %r12, %rdi
callq 0x2d55
movq 0x8(%r15), %rcx
leaq 0x1(%rcx), %rdx
cmpq 0x10(%r15), %rdx
ja 0x6764
movq (%r15), %rsi
movq %rdx, 0x8(%r15)
movq %rax, (%rsi,%rcx,8)
incq %r13
cmpq %r13, 0x10(%r14)
ja 0x6653
callq 0x2c39
movl $0x2, (%rax)
movq %r15, 0x8(%rax)
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
cmpq 0x10(%rbx), %rdx
ja 0x6764
movq (%rbx), %rsi
movq %rdx, 0x8(%rbx)
movq %rax, (%rsi,%rcx,8)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2e91
movq 0x8(%r14), %rcx
leaq -0x248(%rip), %rdi      # 0x649a
xorl %esi, %esi
movq %rbx, %rdx
callq 0x64c9
movq 0x8(%rbx), %rax
leaq 0x1(%rax), %rcx
cmpq 0x10(%rbx), %rcx
ja 0x6764
movq (%rbx), %rdx
movq %rcx, 0x8(%rbx)
movq %r14, (%rdx,%rax,8)
jmp 0x6755
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x677c
movq (%rbx), %rcx
leaq -0x1(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq -0x8(%rcx,%rax,8), %r15
cmpl $0x2, (%r15)
jne 0x6770
movq 0x8(%r15), %rcx
leaq -0x272(%rip), %rdi      # 0x64bf
movq %r14, %rsi
movq %rbx, %rdx
callq 0x64c9
movq 0x8(%rbx), %rax
leaq 0x1(%rax), %rcx
cmpq 0x10(%rbx), %rcx
ja 0x6764
movq (%rbx), %rdx
movq %rcx, 0x8(%rbx)
movq %r15, (%rdx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2eb4(%rip), %rdi      # 0x961f
callq 0x23bc
leaq 0x2be1(%rip), %rdi      # 0x9358
callq 0x23bc
leaq 0x2ed2(%rip), %rdi      # 0x9655
callq 0x23bc