LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/ircode.c
// Function: irinstr_new4
IRInstr* irinstr_new4(op_t op, AddrNode* res, AddrNode* arg1, AddrNode* arg2, int label) {
    IRInstr* p = malloc(sizeof(IRInstr));
#ifdef LOG_MEM
    fprintf(stderr, "%s: Allocated IRInstr %p\n", __func__, (void*)p);
#endif
    irinstr_init4(p, op, res, arg1, arg2, label);
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movl %edi, %r13d
pushq $0x38
popq %rdi
callq 0x3140
movl %r13d, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r12, 0x18(%rax)
movl %ebx, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/ircode.c
// Function: irinstr_link
void irinstr_link(IRInstr* i1, IRInstr* i2) {
    if(i1->next != NULL) {
        fprintf(stderr, "%s: i1 (%p) already has a next.\n", __func__, (void*)i1);
    }
    if(i2->prev != NULL) {
        fprintf(stderr, "%s: i2 (%p) already has a prev.\n", __func__, (void*)i2);
    }
    i1->next = i2;
    i2->prev = i1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x28(%rdi)
jne 0xb266
cmpq $0x0, 0x20(%rbx)
jne 0xb28a
movq %rbx, 0x28(%r14)
movq %r14, 0x20(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8d8b(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
leaq 0x38ba(%rip), %rsi      # 0xeb31
leaq 0x38d4(%rip), %rdx      # 0xeb52
movq %r14, %rcx
xorl %eax, %eax
callq 0x3130
jmp 0xb252
movq 0x8d67(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
leaq 0x38c4(%rip), %rsi      # 0xeb5f
leaq 0x38b0(%rip), %rdx      # 0xeb52
movq %rbx, %rcx
xorl %eax, %eax
callq 0x3130
jmp 0xb259
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/ircode.c
// Function: irinstr_clear
void irinstr_clear(IRInstr* instr) {
    if(instr->prev != NULL) {
        instr->prev->next = NULL;
    }
    if(instr->next != NULL) {
        instr->next->prev = NULL;
    }
    irinstr_init(instr, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0xb2c0
andq $0x0, 0x28(%rax)
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0xb2ce
andq $0x0, 0x20(%rax)
andl $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x24(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/ircode.c
// Function: irinstr_destroy_list
void irinstr_destroy_list(IRInstr* n) {
    IRInstr* p = NULL;
    while(n != NULL) {
        p = n->next;
        irinstr_destroy(n);
        n = p;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb317
movq 0x28(%rdi), %rbx
callq 0xb2e2
movq %rbx, %rdi
jmp 0xb304
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/ircode.c
// Function: irinstr_print
void irinstr_print(IRInstr* n, FILE* fp) {
    fprintf(fp, "Instr(op=%s", OP_STRS[n->op]);
    if(n->op == OP_JUMP0 || n->op == OP_JUMP || n->op == OP_LABEL
        || n->op == OP_JG || n->op == OP_JUMP1) {
        fprintf(fp, ", label=%d", n->label);
    }
    if(n->res != NULL) {
        fprintf(fp, ",\n\tres=");
        AddrNode_print(n->res, fp);
    }
    if(n->arg1 != NULL) {
        fprintf(fp, ",\n\targ1=");
        AddrNode_print(n->arg1, fp);
    }
    if(n->arg2 != NULL) {
        fprintf(fp, ",\n\targ2=");
        AddrNode_print(n->arg2, fp);
    }
    fprintf(fp, ")");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
leaq 0x97cc(%rip), %rcx      # 0x14b00
movq (%rcx,%rax,8), %rdx
leaq 0x3841(%rip), %rsi      # 0xeb80
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3130
movl (%r14), %eax
cmpl $0x15, %eax
ja 0xb370
movl $0x3b0000, %ecx         # imm = 0x3B0000
btl %eax, %ecx
jae 0xb370
movl 0x30(%r14), %edx
leaq 0x3826(%rip), %rsi      # 0xeb8c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3130
cmpq $0x0, 0x18(%r14)
je 0xb398
leaq 0x3819(%rip), %rdi      # 0xeb97
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x31c0
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0xaf96
cmpq $0x0, 0x8(%r14)
je 0xb3c0
leaq 0x37f9(%rip), %rdi      # 0xeb9f
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x31c0
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xaf96
cmpq $0x0, 0x10(%r14)
je 0xb3e8
leaq 0x37da(%rip), %rdi      # 0xeba8
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x31c0
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xaf96
pushq $0x29
popq %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3100
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/./util/llist.gen.c
// Function: ircode_combine
void CLASSED(combine)(CLASS* plist, CLASS* p1, CLASS* p2) {
    plist->size = p1->size + p2->size;
    if(p1->first == NULL) {
        plist->first = p2->first;
        plist->last = p2->last;
    }
    else if(p2->first == NULL) {
        plist->first = p1->first;
        plist->last = p1->last;
    }
    else {
        TYPED(link)(p1->last, p2->first);
        plist->first = p1->first;
        plist->last = p2->last;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x10(%rdx), %eax
addl 0x10(%rsi), %eax
movl %eax, 0x10(%rdi)
movq (%rsi), %rax
movq (%rdx), %rsi
testq %rax, %rax
je 0xb461
testq %rsi, %rsi
je 0xb45b
movq 0x8(%r15), %rdi
callq 0xb23e
movq (%r15), %rsi
jmp 0xb461
movq %rax, %rsi
movq %r15, %r14
movq %rsi, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/./util/llist.gen.c
// Function: ircode_prepend
void CLASSED(prepend)(CLASS* plist, TYPE instr) {
    (plist->size)++;
    if(plist->first == NULL) {
        plist->first = plist->last = instr;
        plist->size = 1;
    }
    else {
        TYPED(link)(instr, plist->first);
        plist->first = instr;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
incl 0x10(%rdi)
movq %rsi, %r14
movq (%rdi), %rsi
testq %rsi, %rsi
je 0xb499
movq %r14, %rdi
callq 0xb23e
jmp 0xb4a4
movq %r14, 0x8(%rbx)
movl $0x1, 0x10(%rbx)
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/./util/llist.gen.c
// Function: ircode_append
void CLASSED(append)(CLASS* plist, TYPE instr) {
    (plist->size)++;
    if(plist->first == NULL) {
        plist->first = plist->last = instr;
        plist->size = 1;
    }
    else {
        TYPED(link)(plist->last, instr);
        plist->last = instr;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
incl 0x10(%rdi)
movq %rsi, %r14
cmpq $0x0, (%rdi)
je 0xb4d4
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0xb23e
movq %r14, 0x8(%rbx)
jmp 0xb4e2
movq %r14, 0x8(%rbx)
movq %r14, (%rbx)
movl $0x1, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/./util/llist.gen.c
// Function: ircode_remove
void CLASSED(remove)(CLASS* plist, TYPE elem) {
    (plist->size)--;
    // first manipulate pointers of list
    if(plist->first == NULL) {
        fprintf(stderr, "Cannot remove from empty linked-list.\n");
        plist->first = plist->last = elem;
        plist->size = 0;
    }
    else if(plist->first == elem) {
        if(plist->last == elem) {
            plist->first = plist->last = NULL;
        }
        else {
            plist->first = plist->first->next;
        }
    }
    else if(plist->last == elem) {
        plist->last = plist->last->prev;
    }
    // now detach elem
    TYPE prev = elem->prev;
    TYPE next = elem->next;
    elem->prev = elem->next = NULL;
    if(next != NULL) {
        next->prev = prev;
    }
    if(prev != NULL) {
        prev->next = next;
    }
    TYPED(destroy)(elem);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
decl 0x10(%rdi)
movq %rsi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xb52e
movq 0x8(%r14), %rcx
cmpq %rbx, %rax
je 0xb517
cmpq %rbx, %rcx
jne 0xb556
movq 0x20(%rcx), %rax
movq %rax, 0x8(%r14)
jmp 0xb556
cmpq %rbx, %rcx
je 0xb525
movq 0x28(%rax), %rax
movq %rax, (%r14)
jmp 0xb556
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
jmp 0xb556
movq 0x8ac3(%rip), %rax      # 0x13ff8
movq (%rax), %rcx
leaq 0x3672(%rip), %rdi      # 0xebb1
pushq $0x26
popq %rsi
pushq $0x1
popq %rdx
callq 0x31c0
movq %rbx, 0x8(%r14)
movq %rbx, (%r14)
andl $0x0, 0x10(%r14)
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
testq %rcx, %rcx
je 0xb56e
movq %rax, 0x20(%rcx)
testq %rax, %rax
je 0xb577
movq %rcx, 0x28(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xb2e2
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/./util/llist.gen.c
// Function: ircode_print
void CLASSED(print)(CLASS* plist, FILE* fp) {
    int i;
    TYPE node = plist->first;
    for(i=0; i<(plist->size); ++i) {
        TYPED(print)(node, fp);
        fprintf(fp, "\n");
        node = node->next;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
pushq $0xa
popq %r15
movq %rdi, %r12
cmpl 0x10(%r14), %r13d
jge 0xb5ec
movq (%r12), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0xb31e
movl %r15d, %edi
movq %rbx, %rsi
callq 0x3100
addq $0x28, %r12
incl %r13d
jmp 0xb5c3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/x86.c
// Function: x86_instr_init
void x86_instr_init(X86Instr* instr, x86_op_t opcode) {
    memset((void*)instr, 0, sizeof(instr));
    instr->next = instr->prev = NULL;
    instr->arg1[0] = instr->arg2[0] = '\0';
    instr->opcode = opcode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $0x0, (%rdi)
movb $0x0, 0x22(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movl %esi, (%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/x86.c
// Function: x86_instr_new
X86Instr* x86_instr_new(x86_op_t opcode) {
    X86Instr* p = malloc(sizeof(X86Instr));
#ifdef LOG_MEM
    fprintf(stderr, "%s: Allocated X86Instr %p\n", __func__, (void*)p);
#endif
    x86_instr_init(p, opcode);
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
pushq $0x50
popq %rdi
callq 0x3140
andq $0x0, (%rax)
movb $0x0, 0x22(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rax)
movl %ebx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/x86.c
// Function: x86_instr_new2
X86Instr* x86_instr_new2(x86_op_t opcode, const char* arg1, const char* arg2) {
    X86Instr* p = malloc(sizeof(X86Instr));
#ifdef LOG_MEM
    fprintf(stderr, "%s: Allocated X86Instr %p\n", __func__, (void*)p);
#endif
    x86_instr_init2(p, opcode, arg1, arg2);
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
pushq $0x50
popq %rdi
callq 0x3140
movq %rax, %r12
movq %rax, %rdi
movl %r15d, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xb613
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/x86.c
// Function: x86_instr_link
void x86_instr_link(X86Instr* i1, X86Instr* i2) {
    if(i1->next != NULL) {
        fprintf(stderr, "%s: i1 (%p) already has a next.\n", __func__, (void*)i1);
    }
    if(i2->prev != NULL) {
        fprintf(stderr, "%s: i2 (%p) already has a prev.\n", __func__, (void*)i2);
    }
    i1->next = i2;
    i2->prev = i1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x48(%rdi)
jne 0xb6eb
cmpq $0x0, 0x40(%rbx)
jne 0xb70f
movq %rbx, 0x48(%r14)
movq %r14, 0x40(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8906(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
leaq 0x3435(%rip), %rsi      # 0xeb31
leaq 0x3537(%rip), %rdx      # 0xec3a
movq %r14, %rcx
xorl %eax, %eax
callq 0x3130
jmp 0xb6d7
movq 0x88e2(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
leaq 0x343f(%rip), %rsi      # 0xeb5f
leaq 0x3513(%rip), %rdx      # 0xec3a
movq %rbx, %rcx
xorl %eax, %eax
callq 0x3130
jmp 0xb6de
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/x86.c
// Function: x86_instr_clear
void x86_instr_clear(X86Instr* instr) {
    if(instr->prev != NULL) {
        instr->prev->next = NULL;
    }
    if(instr->next != NULL) {
        instr->next->prev = NULL;
    }
    x86_instr_init(instr, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0xb745
andq $0x0, 0x48(%rax)
leaq 0x40(%rdi), %rax
movq 0x48(%rdi), %rcx
testq %rcx, %rcx
je 0xb757
andq $0x0, 0x40(%rcx)
andq $0x0, (%rdi)
movb $0x0, 0x22(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/x86.c
// Function: x86_instr_destroy_list
void x86_instr_destroy_list(X86Instr* n) {
    X86Instr* p = NULL;
    while(n != NULL) {
        p = n->next;
        x86_instr_destroy(n);
        n = p;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb79c
movq 0x48(%rdi), %rbx
callq 0xb767
movq %rbx, %rdi
jmp 0xb789
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/x86.c
// Function: x86_instr_print
void x86_instr_print(X86Instr* n, FILE* fp) {
    if(n->opcode == X86_OP_label) {
        fprintf(fp, "%s%s:", X86_INDENT_STR, n->arg1);
    }
    else if(n->arg2[0] != '\0') {
        fprintf(fp, "%s%s %s, %s", X86_INDENT_STR, X86_OP_STRS[n->opcode], n->arg1, n->arg2);
    }
    else if(n->arg1[0] != '\0') {
        fprintf(fp, "%s%s %s", X86_INDENT_STR, X86_OP_STRS[n->opcode], n->arg1);
    }
    else {
        fprintf(fp, "%s%s", X86_INDENT_STR, X86_OP_STRS[n->opcode]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rax
movq %rdi, %r8
movl (%rdi), %ecx
cmpq $0x13, %rcx
jne 0xb7d5
addq $0x4, %r8
leaq 0x3489(%rip), %rsi      # 0xec49
leaq 0x261b(%rip), %rdx      # 0xdde2
movq %rax, %rdi
movq %r8, %rcx
xorl %eax, %eax
popq %rbp
jmp 0x3130
cmpb $0x0, 0x22(%r8)
je 0xb808
leaq 0x22(%r8), %r9
leaq 0x9419(%rip), %rdx      # 0x14c00
movq (%rdx,%rcx,8), %rcx
addq $0x4, %r8
leaq 0x3459(%rip), %rsi      # 0xec4f
leaq 0x25e5(%rip), %rdx      # 0xdde2
movq %rax, %rdi
xorl %eax, %eax
popq %rbp
jmp 0x3130
cmpb $0x0, 0x4(%r8)
leaq 0x93ec(%rip), %rdx      # 0x14c00
movq (%rdx,%rcx,8), %rcx
je 0xb837
addq $0x4, %r8
leaq 0x3436(%rip), %rsi      # 0xec5b
leaq 0x25b6(%rip), %rdx      # 0xdde2
movq %rax, %rdi
xorl %eax, %eax
popq %rbp
jmp 0x3130
leaq 0x3425(%rip), %rsi      # 0xec63
leaq 0x259d(%rip), %rdx      # 0xdde2
movq %rax, %rdi
jmp 0xb7cd
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/compile_x86.c
// Function: enable_output
void enable_output(valtype_t type, int size) {
    include_lib_files[0] = true;
    int index = 1;
    if(size > 0) {
        index += 2;
    }
    if(type == TYPE_BOOLEAN) {
        index++;
    }
    include_lib_files[index] = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x1, %al
movb %al, 0x92bc(%rip)       # 0x14d18
leaq 0x92b5(%rip), %rcx      # 0x14d18
xorl %edx, %edx
testl %esi, %esi
setg %dl
xorl %esi, %esi
cmpl $0x3, %edi
sete %sil
leaq (%rsi,%rdx,2), %rdx
movb %al, 0x1(%rdx,%rcx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/compile_x86.c
// Function: enable_input
void enable_input(valtype_t type) {
    include_lib_files[0] = true;
    int index = 5;
    if(type == TYPE_BOOLEAN) {
        index++;
    }
    include_lib_files[index] = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x1, %al
movb %al, 0x928f(%rip)       # 0x14d18
leaq 0x9288(%rip), %rcx      # 0x14d18
xorl %edx, %edx
cmpl $0x3, %edi
sete %dl
movb %al, 0x5(%rdx,%rcx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/compile_x86.c
// Function: load_index_if_needed
void load_index_if_needed(X86Code* ocode, const AddrNode* an, const char* index_reg) {
    if(an->addr_type == ADDR_ARR && an->index->addr_type == ADDR_VAR) {
        X86Instr* onode = x86_instr_new(X86_OP_mov);
        x86_code_append(ocode, onode);
        strcpy(onode->arg1, index_reg);
        snprintf(onode->arg2, X86_ARG_SIZE, "[%s + %d]", DATA_REG, an->index->offset);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x3, 0x14(%rsi)
jne 0xbca5
movq %rsi, %rbx
movq 0x38(%rsi), %rax
cmpl $0x0, 0x14(%rax)
je 0xbcae
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
movq %rdi, %r15
xorl %edi, %edi
callq 0xb65f
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0xb8ff
leaq 0x4(%r12), %rdi
movq %r14, %rsi
callq 0x3060
addq $0x22, %r12
movq 0x38(%rbx), %rax
movl 0x28(%rax), %r8d
leaq 0x3150(%rip), %rdx      # 0xee39
leaq 0x2fdc(%rip), %rcx      # 0xeccc
pushq $0x1e
popq %rsi
movq %r12, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x30c0
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/compile_x86.c
// Function: op_addr_to_reg
void op_addr_to_reg(X86Code* ocode, x86_op_t opcode, int regno, const AddrNode* an) {
    X86Instr* onode = x86_instr_new2(opcode, std_regs[regno][an->type], NULL);
    load_index_if_needed(ocode, an, "si");
    addr_to_x86_arg(an, onode->arg2, false, "rsi");
    x86_code_append(ocode, onode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %esi, %eax
movq %rdi, %rbx
movslq %edx, %rcx
movl 0x18(%r14), %edx
imulq $0x28, %rcx, %rcx
leaq 0xe1d7(%rip), %rdi      # 0x19f00
addq %rcx, %rdi
imulq $0xa, %rdx, %rsi
addq %rdi, %rsi
movl %eax, %edi
xorl %edx, %edx
callq 0xb687
movq %rax, %r15
leaq 0x3113(%rip), %rdx      # 0xee59
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbc87
leaq 0x22(%r15), %rsi
leaq 0x30fc(%rip), %rcx      # 0xee58
movq %r14, %rdi
xorl %edx, %edx
callq 0xbac4
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb8ff
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/compile_x86.c
// Function: op_reg_to_addr
void op_reg_to_addr(X86Code* ocode, x86_op_t opcode, const AddrNode* an, int regno) {
    X86Instr* onode = x86_instr_new2(opcode, NULL, std_regs[regno][an->type]);
    load_index_if_needed(ocode, an, "di");
    addr_to_x86_arg(an, onode->arg1, false, "rdi");
    x86_code_append(ocode, onode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movslq %ecx, %rax
movl 0x18(%rdx), %ecx
imulq $0x28, %rax, %rax
leaq 0xe164(%rip), %rdi      # 0x19f00
addq %rax, %rdi
imulq $0xa, %rcx, %rdx
addq %rdi, %rdx
movl %esi, %edi
xorl %esi, %esi
callq 0xb687
movq %rax, %r15
leaq 0x30a4(%rip), %rdx      # 0xee5d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbc87
leaq 0x4(%r15), %rsi
leaq 0x308d(%rip), %rcx      # 0xee5c
movq %r14, %rdi
xorl %edx, %edx
callq 0xbac4
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb8ff
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/compile_x86.c
// Function: op_addr_to_addr
void op_addr_to_addr(X86Code* ocode, x86_op_t opcode, const AddrNode* an1, const AddrNode* an2) {
    if((an1->addr_type == ADDR_CONST) != (an2->addr_type == ADDR_CONST)) {
        X86Instr* onode = x86_instr_new2(opcode, NULL, NULL);
        load_index_if_needed(ocode, an1, "si");
        load_index_if_needed(ocode, an2, "di");
        addr_to_x86_arg(an1, onode->arg1, true, "rsi");
        addr_to_x86_arg(an2, onode->arg2, true, "rdi");
        x86_code_append(ocode, onode);
    }
    else {
        op_addr_to_reg(ocode, X86_OP_mov, 0, an2);
        op_reg_to_addr(ocode, opcode, an1, 0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %rbx
cmpl $0x2, 0x14(%rdx)
sete %al
cmpl $0x2, 0x14(%rcx)
setne %cl
xorb %al, %cl
je 0xbe47
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0xbd05
movq %rbx, %rdi
movl %r12d, %esi
movq %r15, %rdx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xbd7b
movl %r12d, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb687
movq %rax, %r12
leaq 0x2ffc(%rip), %rdx      # 0xee59
movq %rbx, %rdi
movq %r15, %rsi
callq 0xbc87
leaq 0x2fee(%rip), %rdx      # 0xee5d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbc87
leaq 0x4(%r12), %rsi
leaq 0x2fd2(%rip), %rcx      # 0xee58
pushq $0x1
popq %r13
movq %r15, %rdi
movl %r13d, %edx
callq 0xbac4
leaq 0x22(%r12), %rsi
leaq 0x2fbb(%rip), %rcx      # 0xee5c
movq %r14, %rdi
movl %r13d, %edx
callq 0xbac4
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb8ff
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/compile_x86.c
// Function: op_apply
void op_apply(X86Code* ocode, x86_op_t opcode, const AddrNode* an) {
    X86Instr* onode = x86_instr_new(opcode);
    load_index_if_needed(ocode, an, "si");
    addr_to_x86_arg(an, onode->arg1, true, "rsi");
    x86_code_append(ocode, onode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %edi
callq 0xb65f
movq %rax, %r15
leaq 0x2f73(%rip), %rdx      # 0xee59
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbc87
leaq 0x4(%r15), %rsi
leaq 0x2f5c(%rip), %rcx      # 0xee58
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0xbac4
movq %r14, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb8ff
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/compile_x86.c
// Function: check_arg
bool check_arg(const AddrNode* an) {
    if(an != NULL && an->type != TYPE_INTEGER && an->type != TYPE_BOOLEAN) {
        print_error("x86_codegen", ERROR, -1, an->line, an->col, TYPE_STRS[an->type],
            "BAD_TYPE", "Bad type of argument");
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movb $0x1, %bl
testq %rdi, %rdi
je 0xbf6e
movl 0x18(%rdi), %eax
movl %eax, %ecx
orl $0x2, %ecx
cmpl $0x3, %ecx
je 0xbf6e
movl 0x20(%rdi), %ecx
movl 0x24(%rdi), %r8d
leaq 0x8c7c(%rip), %rdx      # 0x14bc0
movq (%rdx,%rax,8), %r9
leaq 0x2f1d(%rip), %rax      # 0xee6c
leaq 0x2863(%rip), %r10      # 0xe7b9
leaq 0x2f03(%rip), %rdi      # 0xee60
xorl %ebx, %ebx
pushq $-0x1
popq %rdx
xorl %esi, %esi
pushq %rax
pushq %r10
callq 0x873c
popq %rax
popq %rcx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sharmaeklavya2[P]cerplag/codegen.c
// Function: optimize_ircode
void optimize_ircode(IRCode* code) {
    IRInstr* instr = code->first;
    IRInstr* instr2 = NULL;
    for(; instr != NULL; instr = instr2) {
        instr2 = instr->next;
        while(instr2 != NULL && instr->res != NULL && instr->res->addr_type == ADDR_TEMP && instr2->op == OP_MOV) {
            instr->res = instr2->res;
            instr2 = instr2->next;
            ircode_remove(code, instr->next);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0xccdc
movq 0x28(%r14), %r15
testq %r15, %r15
je 0xccd7
movq 0x18(%r14), %rax
testq %rax, %rax
je 0xccd7
cmpl $0x1, 0x14(%rax)
jne 0xccd7
cmpl $0xc, (%r15)
jne 0xccd7
movq 0x18(%r15), %rax
movq %rax, 0x18(%r14)
movq 0x28(%r15), %r15
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0xb4e7
jmp 0xcca3
movq %r15, %r14
jmp 0xcc9a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/OhYee[P]computer_application_programming_experiment/utils/sort/test/test_sort.c
// Function: test_int
boolean test_int() {
    boolean pass = T;
    int     nums[8] = {5, 1, 4, 2,8, 7, 3, 6};

    sort(0, 7, nums, compare_int, swap_int);
    for (int i = 0; i < 8; i++) {
        if (nums[i] != i + 1) {
            print_err("Error at a[%d]=%d want %d\n", i, nums[i], i + 1);
            pass = F;
        }
    }
    return pass;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0xb07(%rip), %rax       # 0x2004
movl (%rax), %ebx
movaps 0xb8a(%rip), %xmm0      # 0x2090
movq %rsp, %rdx
movaps %xmm0, 0x10(%rdx)
movaps 0xb6c(%rip), %xmm0      # 0x2080
movaps %xmm0, (%rdx)
leaq -0x52(%rip), %rcx       # 0x14cc
leaq -0x4c(%rip), %r8        # 0x14d9
pushq $0x7
popq %rsi
xorl %edi, %edi
callq 0x1398
leaq 0xad2(%rip), %rax       # 0x2008
movl (%rax), %ebp
leaq 0xb61(%rip), %r14       # 0x20a0
xorl %r15d, %r15d
movl %r15d, %esi
negl %esi
cmpq $0x8, %r15
je 0x156f
movl (%rsp,%r15,4), %edx
incq %r15
decl %esi
cmpq %rdx, %r15
je 0x1547
movl %esi, %ecx
negl %ecx
notl %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1228
movl %ebp, %ebx
jmp 0x1542
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/OhYee[P]computer_application_programming_experiment/utils/sort/test/test_sort.c
// Function: pair
boolean pair() {
    boolean pass = T;
    char    keys[7] = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
    int     values[7] = {5, 1, 4, 2, 7, 3, 6};
    void *  args[] = {keys, values};

    char want[7] = {'b', 'd', 'f', 'c', 'a', 'g', 'e'};

    sort(0, 6, args, compare_int, swap_int);
    for (int i = 0; i < 7; i++) {
        if (keys[i] != want[i] || values[i] != i + 1) {
            print_err("Error at %d(%c,%d) want %c\n", i, keys[i], values[i],
                      want[i]);
            pass = F;
        }
    }
    return pass;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0xa3a(%rip), %rax       # 0x2004
movl (%rax), %ebx
leaq 0x8(%rsp), %rax
movl $0x67666564, 0x3(%rax)  # imm = 0x67666564
movl $0x64636261, (%rax)     # imm = 0x64636261
movups 0xb37(%rip), %xmm0      # 0x211c
leaq 0x10(%rsp), %rcx
movups %xmm0, 0xc(%rcx)
movaps 0xb1b(%rip), %xmm0      # 0x2110
movaps %xmm0, (%rcx)
leaq 0x30(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rdx)
leaq -0x13f(%rip), %rcx      # 0x14cc
leaq -0x139(%rip), %r8       # 0x14d9
pushq $0x6
popq %rsi
xorl %edi, %edi
callq 0x1398
leaq 0x9e5(%rip), %rax       # 0x2008
movl (%rax), %ebp
leaq 0xb00(%rip), %r15       # 0x212c
leaq 0xa88(%rip), %r14       # 0x20bb
xorl %r12d, %r12d
leaq (%rsp,%r12,4), %rax
addq $0x10, %rax
leaq (%rsp,%r12), %rsi
addq $0x8, %rsi
xorl %edi, %edi
leaq (%r12,%rdi), %rcx
cmpq $0x7, %rcx
je 0x168d
movsbl (%rsi,%rdi), %edx
movsbl (%r15,%rcx), %r8d
leaq 0x1(%rdi), %r13
movl (%rax,%rdi,4), %ecx
cmpb %r8b, %dl
jne 0x1676
leaq (%r12,%rdi), %r9
incq %r9
movq %r13, %rdi
cmpq %rcx, %r9
je 0x1648
leal (%r12,%r13), %esi
decl %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1228
addq %r13, %r12
movl %ebp, %ebx
jmp 0x1636
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/OhYee[P]computer_application_programming_experiment/utils/sort/test/test_sort.c
// Function: main
int main() {
    boolean pass = T;

    pass &= test_int();

    if (pass) {
        print_ok("All testcases passed\n");
    } else {
        print_err("Some errors!\n");
    }
}

// Assembly:
pushq %rbx
leaq 0x95e(%rip), %rbx       # 0x2004
callq 0x14ec
testl %eax, (%rbx)
je 0x16bf
leaq 0xa21(%rip), %rdi       # 0x20d7
xorl %eax, %eax
callq 0x12e0
jmp 0x16cd
leaq 0xa27(%rip), %rdi       # 0x20ed
xorl %eax, %eax
callq 0x1228
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/ibkvser.c
// Function: main
int
main(int argc, char ** argv)
{
  if (argc < 6) {
    fprintf(stderr, "Usage: %s <ib-port> <host> <port> <depth> api ...\n", argv[0]);
    kvmap_api_helper_message();
    exit(0);
  }

  struct ib_port * const port = ib_port_create(atoi(argv[1]));
  if (port == NULL) {
    fprintf(stderr, "ib_port_create() failed\n");
    exit(0);
  }

  const char * const host = argv[2];
  const int pn = atoi(argv[3]);
  const u64 depth = strtoull(argv[4], NULL, 10);
  struct kvmap_api * api = NULL;
  struct oalloc * const oa = oalloc_create();
  struct kvmap_mm mm = { .af = (kv_alloc_func)oalloc_alloc, .ap = oa, };
  const int n1 = kvmap_api_helper(argc - 5, argv + 5, &api, &mm, false);
  if (n1 < 0 || api == NULL) {
    fprintf(stderr, "kvmap_api_helper() failed\n");
    exit(0);
  }
  struct worker_info wi;
  wi.api = api;
  wi.port = port;
  wi.depth = depth;
  struct server * const ser = server_create(host, pn, kv_worker, &wi);
  if (ser == NULL) {
    fprintf(stderr, "server_create() failed\n");
    exit(0);
  }
  server_wait(ser);
  kvmap_api_destroy(api);
  oalloc_destroy(oa);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
cmpl $0x5, %edi
jle 0x692f
movl %edi, %r12d
movq 0x8(%r14), %rdi
callq 0x63e0
movslq %eax, %rdi
callq 0x112d4
testq %rax, %rax
je 0x6951
movq %rax, %rbx
movq 0x10(%r14), %rax
movq %rax, -0x48(%rbp)
movq 0x18(%r14), %rdi
callq 0x63e0
movl %eax, -0x2c(%rbp)
movq 0x20(%r14), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x6580
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %r13
andq $0x0, (%r13)
callq 0x7f9c
vxorps %xmm0, %xmm0, %xmm0
leaq -0xb0(%rbp), %rcx
vmovups %ymm0, 0x30(%rcx)
vmovups %ymm0, 0x10(%rcx)
movq %rax, %r15
leaq 0x1742(%rip), %rax      # 0x7fe1
movq %rax, (%rcx)
movq %r15, 0x8(%rcx)
addl $-0x5, %r12d
addq $0x28, %r14
movl %r12d, %edi
movq %r14, %rsi
movq %r13, %rdx
xorl %r8d, %r8d
vzeroupper
callq 0xaff4
testl %eax, %eax
js 0x6966
movq -0x38(%rbp), %rax
testq %rax, %rax
je 0x6966
leaq -0x60(%rbp), %rcx
movq %rax, (%rcx)
movq %rbx, 0x8(%rcx)
movq -0x40(%rbp), %rax
movq %rax, 0x10(%rcx)
leaq 0xad(%rip), %rdx        # 0x699e
movq -0x48(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0xa693
testq %rax, %rax
je 0x697b
movq %rax, %rdi
callq 0xa906
movq -0x38(%rbp), %rdi
callq 0xaf28
movq %r15, %rdi
callq 0x8120
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x126b2(%rip), %rax     # 0x18fe8
movq (%rax), %rdi
movq (%r14), %rdx
leaq 0xb6c1(%rip), %rsi      # 0x12004
xorl %eax, %eax
callq 0x6600
callq 0xaf4f
jmp 0x6997
movq 0x12690(%rip), %rax     # 0x18fe8
movq (%rax), %rcx
leaq 0xb6d5(%rip), %rdi      # 0x12037
pushq $0x18
jmp 0x698e
movq 0x1267b(%rip), %rax     # 0x18fe8
movq (%rax), %rcx
leaq 0xb6d9(%rip), %rdi      # 0x12050
pushq $0x1a
jmp 0x698e
movq 0x12666(%rip), %rax     # 0x18fe8
movq (%rax), %rcx
leaq 0xb6df(%rip), %rdi      # 0x1206b
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
callq 0x65d0
xorl %edi, %edi
callq 0x6150
// File: /workspace/github_c_makefile_star2_O2/codeplea[P]tinyexpr/example2.c
// Function: main
int main(int argc, char *argv[])
{
    if (argc < 2) {
        printf("Usage: example2 \"expression\"\n");
        return 0;
    }

    const char *expression = argv[1];
    printf("Evaluating:\n\t%s\n", expression);

    /* This shows an example where the variables
     * x and y are bound at eval-time. */
    double x, y;
    te_variable vars[] = {{"x", &x}, {"y", &y}};

    /* This will compile the expression and check for errors. */
    int err;
    te_expr *n = te_compile(expression, vars, 2, &err);

    if (n) {
        /* The variables can be changed here, and eval can be called as many
         * times as you like. This is fairly efficient because the parsing has
         * already been done. */
        x = 3; y = 4;
        const double r = te_eval(n); printf("Result:\n\t%f\n", r);

        te_free(n);
    } else {
        /* Show the user where the error is at. */
        printf("\t%*s^\nError near here", err-1, "");
    }


    return 0;
}

// Assembly:
pushq %rbx
subq $0x60, %rsp
cmpl $0x1, %edi
jg 0x11d7
leaq 0x1e6f(%rip), %rdi      # 0x303c
callq 0x1060
jmp 0x129b
movq 0x8(%rsi), %rbx
leaq 0x1e22(%rip), %rdi      # 0x3004
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1080
leaq 0x1e22(%rip), %rax      # 0x3015
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsi)
andl $0x0, 0x10(%rsi)
andq $0x0, 0x18(%rsi)
leaq 0x1e03(%rip), %rax      # 0x3017
movq %rax, 0x20(%rsi)
leaq 0x10(%rsp), %rax
movq %rax, 0x28(%rsi)
andl $0x0, 0x30(%rsi)
andq $0x0, 0x38(%rsi)
pushq $0x2
popq %rdx
leaq 0xc(%rsp), %rcx
movq %rbx, %rdi
callq 0x1c0e
testq %rax, %rax
je 0x1280
movq %rax, %rbx
movabsq $0x4008000000000000, %rax # imm = 0x4008000000000000
movq %rax, 0x18(%rsp)
movabsq $0x4010000000000000, %rax # imm = 0x4010000000000000
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
callq 0x1615
leaq 0x1daa(%rip), %rdi      # 0x3019
movb $0x1, %al
callq 0x1080
movq %rbx, %rdi
callq 0x130c
jmp 0x129b
movl 0xc(%rsp), %esi
decl %esi
leaq 0x1d99(%rip), %rdi      # 0x3026
leaq 0x1d91(%rip), %rdx      # 0x3025
xorl %eax, %eax
callq 0x1080
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/attractivechaos[P]rb-eval/rb-cpp.cpp
// Function: test_int(int)
int test_int(int n)
{
	int i, present, cnt = 0;
	uint64_t x = 11;
	intmap_t::node_t *p;
	intmap_t *h = new intmap_t;

	for (i = 0; i < n; ++i) {
		unsigned y = x % (n>>1);
		x = kad_splitmix64(x);
		p = h->find(y);
		if (p == 0) {
			p = h->insert(y, &present);
			p->value = i;
			++cnt;
		} else {
			p = h->erase(y);
			free(p);
			--cnt;
		}
	}
	delete h;
	return cnt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebp
pushq $0x18
popq %rdi
callq 0x1030
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl %ebp, %eax
sarl %eax
cltq
movq %rax, 0x8(%rsp)
xorl %r14d, %r14d
testl %ebp, %ebp
cmovlel %r14d, %ebp
pushq $0xb
popq %r13
leaq 0x4(%rsp), %r15
xorl %r12d, %r12d
cmpl %r12d, %ebp
je 0x126f
movq %r13, %rax
xorl %edx, %edx
divq 0x8(%rsp)
movl %edx, 0x4(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x12d2
movq %rbx, %rdi
movq %r15, %rsi
testq %rax, %rax
je 0x120c
callq 0x1490
movq %rax, %rdi
callq 0x1050
pushq $-0x1
jmp 0x121c
leaq 0x14(%rsp), %rdx
callq 0x12fa
movl %r12d, 0x14(%rax)
pushq $0x1
popq %rax
movabsq $-0x61c8864680b583eb, %rcx # imm = 0x9E3779B97F4A7C15
addq %rcx, %r13
movq %r13, %rcx
shrq $0x1e, %rcx
xorq %r13, %rcx
movabsq $-0x40a7b892e31b1a47, %rdx # imm = 0xBF58476D1CE4E5B9
imulq %rdx, %rcx
movq %rcx, %rdx
shrq $0x1b, %rdx
xorq %rcx, %rdx
movabsq $-0x6b2fb644ecceee15, %rcx # imm = 0x94D049BB133111EB
imulq %rcx, %rdx
movq %rdx, %r13
shrq $0x1f, %r13
xorq %rdx, %r13
addl %eax, %r14d
incl %r12d
jmp 0x11ce
movq %rbx, %rdi
callq 0x17f4
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x1040
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/attractivechaos[P]rb-eval/./rb.hpp
// Function: rbtree_t<unsigned int, rbnode_map_t<unsigned int, int>, int_cmp>::find(unsigned int const&)
inline node_t *find(const key_t &item) {
		node_t *p;
		for (p = root; p;) {
			int cmp = __cmp(item, p->key);
			if (cmp < 0) p = p->rb_link[0];
			else if (cmp > 0) p = p->rb_link[1];
			else return p;
		}
		return 0;
	}

// Assembly:
movq %rdi, %rax
addq $0x8, %rax
movl (%rsi), %ecx
movq (%rax), %rax
testq %rax, %rax
je 0x12f8
xorl %edx, %edx
cmpl 0x10(%rax), %ecx
seta %dl
sbbl $0x0, %edx
js 0x12db
je 0x12f8
addq $0x8, %rax
jmp 0x12db
retq
nop
// File: /workspace/github_c_makefile_star2_O2/attractivechaos[P]rb-eval/./rb.hpp
// Function: rbtree_t<unsigned int, rbnode_map_t<unsigned int, int>, int_cmp>::~rbtree_t()
~rbtree_t() {
		node_t *p, *q;
		for (p = root; p != NULL; p = q) {
			if (p->rb_link[0] == NULL) {
				q = p->rb_link[1];
				::free(p);
			} else {
				q = p->rb_link[0];
				p->rb_link[0] = q->rb_link[1];
				q->rb_link[1] = p;
			}
		}
	}

// Assembly:
pushq %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x1824
movq (%rdi), %rax
testq %rax, %rax
je 0x1816
movq 0x8(%rax), %rcx
movq %rcx, (%rdi)
movq %rdi, 0x8(%rax)
movq %rax, %rdi
jmp 0x17f9
movq 0x8(%rdi), %rbx
callq 0x1050
movq %rbx, %rdi
jmp 0x17f9
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tsoding[P]x11-double-buffering/././db_ximage.c
// Function: db_init
void db_init(DB *db, Display *display, Window window)
{
    db->display = display;
    db->window = window;
    db->gc = XCreateGC(display, window, 0, NULL);
    db->pixels = malloc(sizeof(uint32_t) * WIDTH * HEIGHT);

    XWindowAttributes wa = {0};
    XGetWindowAttributes(display, window, &wa);

    db->image = XCreateImage(display,
                             wa.visual,
                             wa.depth,
                             ZPixmap,
                             0,
                             (char*) db->pixels,
                             WIDTH, HEIGHT,
                             32,
                             WIDTH * sizeof(uint32_t));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x10e0
movq %rax, 0x10(%rbx)
movl $0x1d4c00, %edi         # imm = 0x1D4C00
callq 0x10a0
movq %rax, 0x18(%rbx)
movq %rsp, %r12
movl $0x88, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x1060
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1110
movq 0x18(%r12), %rsi
movl 0x14(%r12), %edx
movq 0x18(%rbx), %r9
pushq $0x2
popq %rcx
movq %r14, %rdi
xorl %r8d, %r8d
pushq $0xc80                  # imm = 0xC80
pushq $0x20
pushq $0x258                  # imm = 0x258
pushq $0x320                  # imm = 0x320
callq 0x1170
addq $0x20, %rsp
movq %rax, 0x20(%rbx)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/tsoding[P]x11-double-buffering/././db_ximage.c
// Function: db_fill_rect
void db_fill_rect(DB *db, int x0, int y0, unsigned int w, unsigned int h)
{
    for (unsigned int dx = 0; dx < w; ++dx) {
        for (unsigned int dy = 0; dy < h; ++dy) {
            int x = x0 + dx;
            int y = y0 + dy;

            if (0 <= x && (unsigned int) x < WIDTH &&
                    0 <= y && (unsigned int) y < HEIGHT) {
                db->pixels[y*WIDTH + x] = 0xFF0000;
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %eax
imull $0x320, %edx, %r8d      # imm = 0x320
addl %esi, %r8d
xorl %r9d, %r9d
cmpl %ecx, %r9d
je 0x13ac
leal (%r9,%rsi), %r10d
movl %edx, %r11d
movl %r8d, %ebx
movq %rax, %r14
subq $0x1, %r14
jb 0x13a4
cmpl $0x320, %r10d           # imm = 0x320
setae %bpl
cmpl $0x258, %r11d           # imm = 0x258
setae %r15b
orb %bpl, %r15b
jne 0x1399
movq 0x18(%rdi), %r15
movl %ebx, %r12d
movl $0xff0000, (%r15,%r12,4) # imm = 0xFF0000
addl $0x320, %ebx            # imm = 0x320
incl %r11d
jmp 0x1369
incl %r9d
incl %r8d
jmp 0x1357
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/otrtool[P]otrtool/src/md5.c
// Function: MD5_Update
void MD5_Update(MD5_CTX *ctx, void *data, unsigned long size)
{
	MD5_u32plus saved_lo;
	unsigned long used, free;

	saved_lo = ctx->lo;
	if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
		ctx->hi++;
	ctx->hi += size >> 29;

	used = saved_lo & 0x3f;

	if (used) {
		free = 64 - used;

		if (size < free) {
			memcpy(&ctx->buffer[used], data, size);
			return;
		}

		memcpy(&ctx->buffer[used], data, free);
		data = (unsigned char *)data + free;
		size -= free;
		body(ctx, ctx->buffer, 64);
	}

	if (size >= 64) {
		data = body(ctx, data, size & ~(unsigned long)0x3f);
		size &= 0x3f;
	}

	memcpy(ctx->buffer, data, size);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
leal (%rdx,%rax), %ecx
andl $0x1fffffff, %ecx       # imm = 0x1FFFFFFF
movl %ecx, (%rdi)
movq %rdx, %rdi
shrq $0x1d, %rdi
cmpl %eax, %ecx
adcl %edi, 0x4(%rbx)
movq %rsi, %r14
andq $0x3f, %rax
je 0x25ef
pushq $0x40
popq %r12
subq %rax, %r12
movq %rdx, %r15
leaq (%rbx,%rax), %rdi
addq $0x18, %rdi
subq %r12, %r15
jae 0x25f4
movq %r14, %rsi
jmp 0x2640
movq %rdx, %r15
jmp 0x2614
leaq 0x18(%rbx), %r13
movq %r14, %rsi
movq %r12, %rdx
callq 0x2170
addq %r12, %r14
pushq $0x40
popq %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x264e
cmpq $0x40, %r15
jb 0x2633
movq %r15, %rdx
andq $-0x40, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x264e
movq %rax, %r14
andl $0x3f, %r15d
addq $0x18, %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2170
// File: /workspace/github_c_makefile_star2_O2/otrtool[P]otrtool/src/md5.c
// Function: MD5
unsigned char * MD5(const unsigned char *d, unsigned long n,
										unsigned char *md) {
	/* This function was added by PyroPeter to allow reusal of old
	 * openssl-dependent code */
	
	MD5_CTX ctx;
	memset(&ctx, 0, sizeof(MD5_CTX));
	MD5_Init(&ctx);
	
	MD5_Update(&ctx, (void *) d, n);
	
	unsigned char *result = (md ? md : (unsigned char *) staticmd);
	MD5_Final(result, &ctx);
	return staticmd;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
xorps %xmm0, %xmm0
movq %rsp, %r14
movups %xmm0, 0x88(%r14)
movups %xmm0, 0x78(%r14)
movups %xmm0, 0x68(%r14)
movups %xmm0, 0x58(%r14)
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x18(%r14)
movabsq $0x1032547698badcfe, %rax # imm = 0x1032547698BADCFE
movq %rax, 0x10(%r14)
movaps 0x3fba(%rip), %xmm0     # 0x7010
movaps %xmm0, (%r14)
movq %r14, %rdi
callq 0x25a5
testq %rbx, %rbx
leaq 0x9204(%rip), %r15      # 0xc270
cmoveq %r15, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2ee1
movq %r15, %rax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/otrtool[P]otrtool/src/blowfish.c
// Function: bf_init
void bf_init(bf_state_t *st, void *key_, size_t keylen)
{
  uint8_t *key = key_;
  int i, j;
  size_t ki;
  uint32_t k;
  uint32_t xL, xR;

  if (keylen < 1 || keylen > 56)
    return;

  /* step 1 */
  memcpy(st->S, S0, sizeof(S0));
  memcpy(st->P, P0, sizeof(P0));

  /* step 2 */
  ki = 0;
  for (i=0; i<18; i++) {
    k = 0;
    for (j=0; j<4; j++) {
      k = (k << 8) | key[ki];
      if (++ki >= keylen) ki = 0;
    }
    st->P[i] ^= k;
  }

  /* steps 3 to 7 */
  xL = xR = 0;
  for (i=0; i<18; i+=2) {
    BF_ENCRYPT(st, xL, xR);
    st->P[i] = xL;
    st->P[i+1] = xR;
  }
  for (i=0; i<4; i++) {
    for (j=0; j<256; j+=2) {
      BF_ENCRYPT(st, xL, xR);
      st->S[i][j] = xL;
      st->S[i][j+1] = xR;
    }
  }
}

// Assembly:
leaq -0x39(%rdx), %rax
cmpq $-0x38, %rax
jb 0x31f9
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x3f6b(%rip), %rsi      # 0x7020
movl $0x1000, %edx           # imm = 0x1000
callq 0x2170
leaq 0x1000(%rbx), %rax
leaq 0x4f53(%rip), %rsi      # 0x8020
pushq $0x12
popq %rcx
movq %rax, %rdi
rep  movsl (%rsi), %es:(%rdi)
xorl %ecx, %ecx
pushq $0x4
popq %rdx
xorl %esi, %esi
xorl %edi, %edi
cmpq $0x12, %rsi
je 0x3111
xorl %r8d, %r8d
movl %edx, %r9d
subl $0x1, %r9d
jb 0x3108
shll $0x8, %r8d
movzbl (%r15,%rdi), %r10d
orl %r10d, %r8d
incq %rdi
cmpq %r14, %rdi
cmovaeq %rcx, %rdi
jmp 0x30ea
xorl %r8d, (%rax,%rsi,4)
incq %rsi
jmp 0x30de
xorl %r15d, %r15d
xorl %eax, %eax
xorl %r14d, %r14d
cmpq $0x11, %r15
ja 0x3174
movl $0x400, %r12d           # imm = 0x400
cmpq $0x410, %r12            # imm = 0x410
je 0x3149
movl %eax, %ebp
xorl (%rbx,%r12,4), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x31fa
xorl %r14d, %eax
incq %r12
movl %ebp, %r14d
jmp 0x3125
movl %eax, %ecx
xorl 0x1040(%rbx), %ecx
xorl 0x1044(%rbx), %r14d
movl %r14d, 0x1000(%rbx,%r15,4)
movl %ecx, 0x1004(%rbx,%r15,4)
addq $0x2, %r15
movl %r14d, %eax
movl %ecx, %r14d
jmp 0x3119
xorl %r12d, %r12d
cmpq $0x4, %r12
je 0x31eb
movq %r12, (%rsp)
shlq $0xa, %r12
addq %rbx, %r12
xorl %r13d, %r13d
cmpq $0xff, %r13
ja 0x31e2
movl $0x400, %r15d           # imm = 0x400
cmpq $0x410, %r15            # imm = 0x410
je 0x31be
movl %eax, %ebp
xorl (%rbx,%r15,4), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x31fa
xorl %r14d, %eax
incq %r15
movl %ebp, %r14d
jmp 0x319a
movl %eax, %ecx
xorl 0x1040(%rbx), %ecx
xorl 0x1044(%rbx), %r14d
movl %r14d, (%r12,%r13,4)
movl %ecx, 0x4(%r12,%r13,4)
addq $0x2, %r13
movl %r14d, %eax
movl %ecx, %r14d
jmp 0x318b
movq (%rsp), %r12
incq %r12
jmp 0x3177
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/otrtool[P]otrtool/src/blowfish.c
// Function: bf_ecb_decrypt
void bf_ecb_decrypt(const bf_state_t *st, void *data_, size_t len)
{
  uint8_t *data = data_;
  uint32_t xL, xR;
  size_t i;

  for (i=0; i<=len-8; i+=8) {
    xL = load_uint32le(data+i);
    xR = load_uint32le(data+i+4);
    BF_DECRYPT(st, xL, xR);
    store_uint32le(data+i, xL);
    store_uint32le(data+i+4, xR);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r14
addq $-0x8, %rdx
movq %rdx, (%rsp)
xorl %ebp, %ebp
cmpq (%rsp), %rbp
ja 0x32e0
movl (%r12,%rbp), %eax
movl 0x4(%r12,%rbp), %ebx
movl $0x411, %r13d           # imm = 0x411
leaq -0x400(%r13), %rcx
cmpq $0x2, %rcx
jb 0x328d
movl %eax, %r15d
xorl (%r14,%r13,4), %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x31fa
xorl %ebx, %eax
decq %r13
movl %r15d, %ebx
jmp 0x3264
xorl 0x1004(%r14), %eax
xorl 0x1000(%r14), %ebx
movl %ebx, %ecx
shrl $0x10, %ecx
movl %ebx, %edx
shrl $0x18, %edx
movq %r12, %rsi
movb %dl, 0x3(%r12,%rbp)
movb %cl, 0x2(%r12,%rbp)
movb %bh, 0x1(%rsi,%rbp)
movb %bl, (%r12,%rbp)
movl %eax, %ecx
shrl $0x10, %ecx
movl %eax, %edx
shrl $0x18, %edx
movb %dl, 0x7(%r12,%rbp)
movb %cl, 0x6(%r12,%rbp)
movb %ah, 0x5(%rsi,%rbp)
movb %al, 0x4(%r12,%rbp)
addq $0x8, %rbp
jmp 0x324b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/otrtool[P]otrtool/src/blowfish.c
// Function: bf_cbc_encrypt
void bf_cbc_encrypt(const bf_state_t *st, void *data_, size_t len, void *iv_)
{
  uint8_t *data = data_;
  uint8_t *iv = iv_;
  uint32_t xL, xR;
  uint32_t ivL, ivR;
  size_t i;

  ivL = load_uint32le(iv);
  ivR = load_uint32le(iv+4);

  for (i=0; i<=len-8; i+=8) {
    xL = load_uint32le(data+i) ^ ivL;
    xR = load_uint32le(data+i+4) ^ ivR;
    BF_ENCRYPT(st, xL, xR);
    store_uint32le(data+i, xL);
    store_uint32le(data+i+4, xR);
    ivL = xL;
    ivR = xR;
  }

  store_uint32le(iv, ivL);
  store_uint32le(iv+4, ivR);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl (%rcx), %eax
movq %rcx, 0x8(%rsp)
movl 0x4(%rcx), %ebx
addq $-0x8, %rdx
movq %rdx, 0x10(%rsp)
xorl %ebp, %ebp
cmpq 0x10(%rsp), %rbp
ja 0x33b0
xorl (%r14,%rbp), %eax
xorl 0x4(%r14,%rbp), %ebx
movl $0x400, %r13d           # imm = 0x400
cmpq $0x410, %r13            # imm = 0x410
je 0x3357
movl %eax, %r12d
xorl (%r15,%r13,4), %r12d
movq %r15, %rdi
movl %r12d, %esi
callq 0x31fa
xorl %ebx, %eax
incq %r13
movl %r12d, %ebx
jmp 0x3332
movl %eax, %ecx
xorl 0x1040(%r15), %ecx
xorl 0x1044(%r15), %ebx
movl %ebx, %eax
shrl $0x10, %eax
movl %ebx, %edx
shrl $0x18, %edx
movq %r14, %rsi
movb %dl, 0x3(%r14,%rbp)
movb %al, 0x2(%r14,%rbp)
movb %bh, 0x1(%rsi,%rbp)
movb %bl, (%r14,%rbp)
movl %ecx, %eax
shrl $0x10, %eax
movl %ecx, %edx
shrl $0x18, %edx
movb %dl, 0x7(%r14,%rbp)
movb %al, 0x6(%r14,%rbp)
movb %ch, 0x5(%rsi,%rbp)
movb %cl, 0x4(%r14,%rbp)
addq $0x8, %rbp
movl %ebx, %eax
movl %ecx, %ebx
jmp 0x3318
movl %eax, %ecx
shrl $0x10, %ecx
movl %eax, %edx
shrl $0x18, %edx
movq 0x8(%rsp), %rsi
movb %dl, 0x3(%rsi)
movb %cl, 0x2(%rsi)
movb %ah, 0x1(%rsi)
movb %al, (%rsi)
movl %ebx, %eax
shrl $0x10, %eax
movl %ebx, %ecx
shrl $0x18, %ecx
movb %cl, 0x7(%rsi)
movb %al, 0x6(%rsi)
movb %bh, 0x5(%rsi)
movb %bl, 0x4(%rsi)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq