LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0x0, 0x10(%rdi)
jle 0xc5f9
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movq %rdi, %r15
movq (%r15), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xc31d
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3110
addq $0x28, %r15
incl %r12d
cmpl 0x10(%r14), %r12d
jl 0xc5c9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
movq $0x0, (%rdi)
xorl %eax, %eax
movb %al, 0x22(%rdi)
movb %al, 0x4(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movl %esi, (%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x50, %edi
callq 0x3150
movq $0x0, (%rax)
xorl %ecx, %ecx
movb %cl, 0x22(%rax)
movb %cl, 0x4(%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_O1/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
movl $0x50, %edi
callq 0x3150
movq %rax, %r12
movq %rax, %rdi
movl %r15d, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xc61a
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc704
cmpq $0x0, 0x40(%rbx)
jne 0xc728
movq %rbx, 0x48(%r14)
movq %r14, 0x40(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq 0x88ed(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
leaq 0x341c(%rip), %rsi      # 0xfb31
leaq 0x351e(%rip), %rdx      # 0xfc3a
movq %r14, %rcx
xorl %eax, %eax
callq 0x3140
jmp 0xc6f0
movq 0x88c9(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
leaq 0x3426(%rip), %rsi      # 0xfb5f
leaq 0x34fa(%rip), %rdx      # 0xfc3a
movq %rbx, %rcx
xorl %eax, %eax
callq 0x3140
jmp 0xc6f7
// File: /workspace/github_c_makefile_star2_O1/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 0xc761
movq $0x0, 0x48(%rax)
leaq 0x40(%rdi), %rax
movq 0x48(%rdi), %rcx
testq %rcx, %rcx
je 0xc776
movq $0x0, 0x40(%rcx)
movb $0x0, 0x22(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, (%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharmaeklavya2[P]cerplag/x86.c
// Function: x86_instr_destroy
void x86_instr_destroy(X86Instr* instr) {
    x86_instr_clear(instr);
    free(instr);
#ifdef LOG_MEM
    fprintf(stderr, "%s: Destroyed X86Instr %p\n", __func__, (void*)instr);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0xc79e
movq $0x0, 0x48(%rax)
leaq 0x40(%rdi), %rax
movq 0x48(%rdi), %rcx
testq %rcx, %rcx
je 0xc7b3
movq $0x0, 0x40(%rcx)
movb $0x0, 0x22(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, (%rdi)
popq %rbp
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0xc7ec
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x48(%rdi), %rbx
callq 0xc789
movq %rbx, %rdi
testq %rbx, %rbx
jne 0xc7d5
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc81f
addq $0x4, %r8
leaq 0x343f(%rip), %rsi      # 0xfc49
leaq 0x25d1(%rip), %rdx      # 0xede2
movq %rax, %rdi
movq %r8, %rcx
xorl %eax, %eax
popq %rbp
jmp 0x3140
cmpb $0x0, 0x22(%r8)
je 0xc852
leaq 0x22(%r8), %r9
leaq 0x93cf(%rip), %rdx      # 0x15c00
movq (%rdx,%rcx,8), %rcx
addq $0x4, %r8
leaq 0x340f(%rip), %rsi      # 0xfc4f
leaq 0x259b(%rip), %rdx      # 0xede2
movq %rax, %rdi
xorl %eax, %eax
popq %rbp
jmp 0x3140
cmpb $0x0, 0x4(%r8)
leaq 0x93a2(%rip), %rdx      # 0x15c00
movq (%rdx,%rcx,8), %rcx
je 0xc881
addq $0x4, %r8
leaq 0x33ec(%rip), %rsi      # 0xfc5b
leaq 0x256c(%rip), %rdx      # 0xede2
movq %rax, %rdi
xorl %eax, %eax
popq %rbp
jmp 0x3140
leaq 0x33db(%rip), %rsi      # 0xfc63
leaq 0x2553(%rip), %rdx      # 0xede2
movq %rax, %rdi
jmp 0xc817
// File: /workspace/github_c_makefile_star2_O1/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, 0x9280(%rip)       # 0x15d18
leaq 0x9279(%rip), %rcx      # 0x15d18
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_O1/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, 0x9253(%rip)       # 0x15d18
leaq 0x924c(%rip), %rcx      # 0x15d18
xorl %edx, %edx
cmpl $0x3, %edi
sete %dl
movb %al, 0x5(%rdx,%rcx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xccc3
movq %rsi, %rbx
movq 0x38(%rsi), %rax
cmpl $0x0, 0x14(%rax)
je 0xcccc
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
movq %rdi, %r15
xorl %edi, %edi
callq 0xc66d
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0xc94f
leaq 0x4(%r12), %rdi
movq %r14, %rsi
callq 0x3060
addq $0x22, %r12
movq 0x38(%rbx), %rax
movl 0x28(%rax), %r8d
leaq 0x3132(%rip), %rdx      # 0xfe39
leaq 0x2fbe(%rip), %rcx      # 0xfccc
movl $0x1e, %esi
movq %r12, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x30c0
// File: /workspace/github_c_makefile_star2_O1/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
leaq (%rcx,%rcx,4), %rcx
leaq 0xe1b7(%rip), %rsi      # 0x1af00
leaq (%rsi,%rcx,8), %rcx
leaq (%rdx,%rdx,4), %rdx
leaq (%rcx,%rdx,2), %rsi
movl %eax, %edi
xorl %edx, %edx
callq 0xc69e
movq %rax, %r15
leaq 0x30f1(%rip), %rdx      # 0xfe59
movq %rbx, %rdi
movq %r14, %rsi
callq 0xcca5
leaq 0x22(%r15), %rsi
leaq 0x30da(%rip), %rcx      # 0xfe58
movq %r14, %rdi
xorl %edx, %edx
callq 0xcae0
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc94f
// File: /workspace/github_c_makefile_star2_O1/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
leaq (%rax,%rax,4), %rax
leaq 0xe142(%rip), %rdx      # 0x1af00
leaq (%rdx,%rax,8), %rax
leaq (%rcx,%rcx,4), %rcx
leaq (%rax,%rcx,2), %rdx
movl %esi, %edi
xorl %esi, %esi
callq 0xc69e
movq %rax, %r15
leaq 0x3080(%rip), %rdx      # 0xfe5d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xcca5
leaq 0x4(%r15), %rsi
leaq 0x3069(%rip), %rcx      # 0xfe5c
movq %r14, %rdi
xorl %edx, %edx
callq 0xcae0
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc94f
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
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 0xce62
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0xcd25
movq %rbx, %rdi
movl %r12d, %esi
movq %r15, %rdx
xorl %ecx, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xcd9d
movl %r12d, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc69e
movq %rax, %r12
leaq 0x2fe1(%rip), %rdx      # 0xfe59
movq %rbx, %rdi
movq %r15, %rsi
callq 0xcca5
leaq 0x2fd3(%rip), %rdx      # 0xfe5d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xcca5
leaq 0x4(%r12), %rsi
leaq 0x2fb7(%rip), %rcx      # 0xfe58
movq %r15, %rdi
movl $0x1, %edx
callq 0xcae0
leaq 0x22(%r12), %rsi
leaq 0x2fa2(%rip), %rcx      # 0xfe5c
movq %r14, %rdi
movl $0x1, %edx
callq 0xcae0
movq %rbx, %rdi
movq %r12, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc94f
// File: /workspace/github_c_makefile_star2_O1/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 0xc66d
movq %rax, %r15
leaq 0x2f5e(%rip), %rdx      # 0xfe59
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcca5
leaq 0x4(%r15), %rsi
leaq 0x2f47(%rip), %rcx      # 0xfe58
movq %rbx, %rdi
movl $0x1, %edx
callq 0xcae0
movq %r14, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc94f
// File: /workspace/github_c_makefile_star2_O1/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 0xcf89
movl 0x18(%rdi), %eax
movl %eax, %ecx
orl $0x2, %ecx
cmpl $0x3, %ecx
je 0xcf89
movl 0x20(%rdi), %ecx
movl 0x24(%rdi), %r8d
leaq 0x8c65(%rip), %rdx      # 0x15bc0
movq (%rdx,%rax,8), %r9
leaq 0x2f06(%rip), %rax      # 0xfe6c
leaq 0x284c(%rip), %r10      # 0xf7b9
leaq 0x2eec(%rip), %rdi      # 0xfe60
xorl %ebx, %ebx
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
pushq %rax
pushq %r10
callq 0x94d4
addq $0x10, %rsp
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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), %r15
testq %r15, %r15
je 0xdd5d
movq %rdi, %rbx
movq 0x28(%r15), %r14
testq %r14, %r14
je 0xdd55
movq 0x18(%r15), %rax
testq %rax, %rax
je 0xdd55
cmpl $0x1, 0x14(%rax)
jne 0xdd55
cmpl $0xc, (%r14)
jne 0xdd55
movq 0x18(%r14), %rax
movq %rax, 0x18(%r15)
movq 0x28(%r14), %r14
movq 0x28(%r15), %rsi
movq %rbx, %rdi
callq 0xc4fa
jmp 0xdd21
movq %r14, %r15
testq %r14, %r14
jne 0xdd1d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x20, %rsp
leaq 0xa9d(%rip), %rax       # 0x2004
movl (%rax), %ebx
movaps 0xb20(%rip), %xmm0      # 0x2090
movq %rsp, %rdx
movaps %xmm0, 0x10(%rdx)
movaps 0xb02(%rip), %xmm0      # 0x2080
movaps %xmm0, (%rdx)
leaq -0x54(%rip), %rcx       # 0x1534
leaq -0x4e(%rip), %r8        # 0x1541
xorl %edi, %edi
movl $0x7, %esi
callq 0x13c4
leaq 0xa66(%rip), %rax       # 0x2008
movl (%rax), %r12d
movl $0x1, %r14d
leaq 0xaee(%rip), %r15       # 0x20a0
xorl %ebp, %ebp
movl -0x4(%rsp,%r14,4), %edx
cmpq %rdx, %r14
je 0x15d0
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %ecx
xorl %eax, %eax
callq 0x1070
movl %r12d, %ebx
incl %ebp
incq %r14
cmpq $0x9, %r14
jne 0x15b4
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/OhYee[P]computer_application_programming_experiment/utils/sort/test/test_sort.c
// Function: swap_pair
void swap_pair(void *args, int i, int j) {
    char *args_keys = (char *)(((void **)args)[0]);
    int * args_values = (int *)(((void **)args)[1]);

    char temp_key = args_keys[i];
    args_keys[i] = args_keys[j];
    args_keys[j] = temp_key;

    int temp_value = args_values[i];
    args_values[i] = args_values[j];
    args_values[j] = temp_value;
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movslq %esi, %rsi
movb (%rax,%rsi), %dil
movslq %edx, %rdx
movb (%rax,%rdx), %r8b
movb %r8b, (%rax,%rsi)
movb %dil, (%rax,%rdx)
movl (%rcx,%rsi,4), %eax
movl (%rcx,%rdx,4), %edi
movl %edi, (%rcx,%rsi,4)
movl %eax, (%rcx,%rdx,4)
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x40, %rsp
leaq 0x9ce(%rip), %rax       # 0x2004
movl (%rax), %ebx
leaq 0x8(%rsp), %rax
movl $0x67666564, 0x3(%rax)  # imm = 0x67666564
movl $0x64636261, (%rax)     # imm = 0x64636261
movups 0xacb(%rip), %xmm0      # 0x211c
leaq 0x10(%rsp), %rcx
movups %xmm0, 0xc(%rcx)
movaps 0xaaf(%rip), %xmm0      # 0x2110
movaps %xmm0, (%rcx)
leaq 0x30(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rdx)
leaq -0x143(%rip), %rcx      # 0x1534
leaq -0x13d(%rip), %r8       # 0x1541
xorl %edi, %edi
movl $0x6, %esi
callq 0x13c4
leaq 0x977(%rip), %rax       # 0x2008
movl (%rax), %ebp
leaq 0xa92(%rip), %r12       # 0x212c
leaq 0xa1a(%rip), %r14       # 0x20bb
xorl %r15d, %r15d
movsbl 0x8(%rsp,%r15), %edx
movsbl (%r15,%r12), %r8d
cmpb %r8b, %dl
jne 0x16c2
movl 0x10(%rsp,%r15,4), %eax
leaq 0x1(%r15), %rcx
cmpq %rax, %rcx
je 0x16d6
movl 0x10(%rsp,%r15,4), %ecx
movq %r14, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x1070
movl %ebp, %ebx
incq %r15
cmpq $0x7, %r15
jne 0x16a4
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x90e(%rip), %rbx       # 0x2004
callq 0x1554
testl %eax, (%rbx)
je 0x170f
leaq 0x9d1(%rip), %rdi       # 0x20d7
xorl %eax, %eax
callq 0x1301
jmp 0x171d
leaq 0x9d7(%rip), %rdi       # 0x20ed
xorl %eax, %eax
callq 0x1070
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r15
cmpl $0x5, %edi
jle 0x7130
movl %edi, %r12d
movq 0x8(%r15), %rdi
callq 0x63e0
movslq %eax, %rdi
callq 0x14518
testq %rax, %rax
je 0x7138
movq %rax, %rbx
movq 0x10(%r15), %rax
movq %rax, -0x48(%rbp)
movq 0x18(%r15), %rdi
callq 0x63e0
movl %eax, -0x2c(%rbp)
movq 0x20(%r15), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x6580
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %r13
movq $0x0, (%r13)
callq 0x880a
vxorps %xmm0, %xmm0, %xmm0
leaq -0xb0(%rbp), %rcx
vmovups %ymm0, (%rcx)
vmovups %ymm0, 0x30(%rcx)
vmovups %ymm0, 0x20(%rcx)
movq %rax, %r14
leaq 0x17b1(%rip), %rax      # 0x8859
movq %rax, (%rcx)
movq %r14, 0x8(%rcx)
addl $-0x5, %r12d
addq $0x28, %r15
movl %r12d, %edi
movq %r15, %rsi
movq %r13, %rdx
xorl %r8d, %r8d
vzeroupper
callq 0xc010
testl %eax, %eax
js 0x713d
movq -0x38(%rbp), %rax
testq %rax, %rax
je 0x713d
leaq -0x60(%rbp), %rcx
movq %rax, (%rcx)
movq %rbx, 0x8(%rcx)
movq -0x40(%rbp), %rax
movq %rax, 0x10(%rcx)
leaq 0x55(%rip), %rdx        # 0x7147
movq -0x48(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0xb61f
testq %rax, %rax
je 0x7142
movq %rax, %rdi
callq 0xb8aa
movq -0x38(%rbp), %rdi
callq 0xbfe7
movq %r14, %rdi
callq 0x8a5e
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x6795
callq 0x676e
callq 0x6747
callq 0x6720
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x68, %rsp
cmpl $0x1, %edi
jg 0x11e9
leaq 0x1e5d(%rip), %rdi      # 0x303c
callq 0x1060
jmp 0x12b0
movq 0x8(%rsi), %rbx
leaq 0x1e10(%rip), %rdi      # 0x3004
xorl %r14d, %r14d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1080
leaq 0x1e0d(%rip), %rax      # 0x3015
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsi)
movl %r14d, 0x10(%rsi)
movq %r14, 0x18(%rsi)
leaq 0x1def(%rip), %rax      # 0x3017
movq %rax, 0x20(%rsi)
leaq 0x10(%rsp), %rax
movq %rax, 0x28(%rsi)
movl %r14d, 0x30(%rsi)
movq %r14, 0x38(%rsi)
leaq 0xc(%rsp), %rcx
movq %rbx, %rdi
movl $0x2, %edx
callq 0x1cd6
testq %rax, %rax
je 0x1295
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 0x16dd
leaq 0x1d95(%rip), %rdi      # 0x3019
movb $0x1, %al
callq 0x1080
movq %rbx, %rdi
callq 0x13ab
jmp 0x12b0
movl 0xc(%rsp), %esi
decl %esi
leaq 0x1d84(%rip), %rdi      # 0x3026
leaq 0x1d7c(%rip), %rdx      # 0x3025
xorl %eax, %eax
callq 0x1080
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x18, %edi
callq 0x1030
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
testl %ebp, %ebp
jle 0x12e3
movq %rbx, %r12
addq $0x8, %r12
movl %ebp, 0x10(%rsp)
movl %ebp, %r15d
shrl %r15d
movl $0xb, %r13d
xorl %ebp, %ebp
xorl %r14d, %r14d
movq %r13, %rax
xorl %edx, %edx
divq %r15
movl %edx, 0xc(%rsp)
movabsq $-0x61c8864680b583eb, %rax # imm = 0x9E3779B97F4A7C15
addq %rax, %r13
movq %r13, %rax
shrq $0x1e, %rax
xorq %r13, %rax
movabsq $-0x40a7b892e31b1a47, %rcx # imm = 0xBF58476D1CE4E5B9
imulq %rcx, %rax
movq %rax, %rcx
shrq $0x1b, %rcx
xorq %rax, %rcx
movabsq $-0x6b2fb644ecceee15, %rax # imm = 0x94D049BB133111EB
imulq %rax, %rcx
movq %rcx, %r13
shrq $0x1f, %r13
xorq %rcx, %r13
movq (%r12), %rax
testq %rax, %rax
je 0x129d
xorl %esi, %esi
xorl %edi, %edi
cmpl %edx, 0x10(%rax)
setb %sil
seta %dil
subl %edi, %esi
js 0x1289
je 0x1291
addq $0x8, %rax
movq (%rax), %rax
movb $0x1, %sil
jmp 0x1296
xorl %esi, %esi
movq %rax, %rcx
testb %sil, %sil
jne 0x126b
jmp 0x129f
xorl %ecx, %ecx
movq %rbx, %rdi
leaq 0xc(%rsp), %rsi
testq %rcx, %rcx
je 0x12c0
callq 0x14b4
movq %rax, %rdi
callq 0x1050
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x12d2
leaq 0x14(%rsp), %rdx
callq 0x130e
movl %ebp, 0x14(%rax)
movl $0x1, %eax
addl %eax, %r14d
incl %ebp
cmpl 0x10(%rsp), %ebp
jne 0x1214
jmp 0x12e6
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x1830
movl $0x18, %esi
movq %rbx, %rdi
callq 0x1040
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x1861
pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x184f
movq 0x8(%rbx), %rax
movq %rax, (%rdi)
movq %rdi, 0x8(%rbx)
jmp 0x1858
movq 0x8(%rdi), %rbx
callq 0x1050
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x183a
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %r14, %rdi
movl $0x2, %ecx
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_O1/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:
testl %ecx, %ecx
je 0x13e8
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %eax
imull $0x320, %edx, %r9d      # imm = 0x320
addl %esi, %r9d
xorl %r10d, %r10d
testl %r8d, %r8d
je 0x13d5
leal (%r10,%rsi), %r11d
movq %rax, %rbx
movl %edx, %ebp
movl %r9d, %r14d
cmpl $0x320, %r11d           # imm = 0x320
setae %r15b
cmpl $0x258, %ebp            # imm = 0x258
setae %r12b
orb %r15b, %r12b
jne 0x13c7
movq 0x18(%rdi), %r15
movl %r14d, %r12d
movl $0xff0000, (%r15,%r12,4) # imm = 0xFF0000
addl $0x320, %r14d           # imm = 0x320
incl %ebp
decq %rbx
jne 0x139e
incl %r10d
incl %r9d
cmpl %ecx, %r10d
jne 0x138d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/otrtool[P]otrtool/src/main.c
// Function: perrorf
void perrorf(const char *fmt, ...) {
  int errsv = errno;
  va_list ap; va_start(ap, fmt); vfprintf(stderr, fmt, ap); va_end(ap);
  fputs(": ", stderr);
  errno = errsv; perror(NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %rsi, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0x24f4
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
callq 0x2030
movq %rax, %r14
movl (%rax), %ebp
movq %rsp, %rdx
movq %r15, 0x10(%rdx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq 0x9ab3(%rip), %r15      # 0xbfd8
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x2310
movq (%r15), %rsi
leaq 0x61fd(%rip), %rdi      # 0x8737
callq 0x2240
movl %ebp, (%r14)
xorl %edi, %edi
callq 0x2170
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/otrtool[P]otrtool/src/main.c
// Function: dumpHex
void dumpHex(void *data_, int len) {
  unsigned char *data = data_;
  unsigned char *line = malloc(sizeof(char) * LINE_LENGTH + 1);
  char *hexrep_orig = bin2hex(data, len);
  char *hexrep = hexrep_orig;
  int i, pos;
  
  for (pos = 0 ; pos < len ; pos += 16) {
    for (i = 0 ; i < 8 ; i++) {
      line[i*3]   = pos+i < len ? hexrep[i*2] : ' ';
      line[i*3+1] = pos+i < len ? hexrep[i*2+1] : ' ';
      line[i*3+2] = ' ';
    }
    line[24] = ' ';
    for (i = 8 ; i < 16 ; i++) {
      line[i*3+1] = pos+i < len ? hexrep[i*2] : ' ';
      line[i*3+2] = pos+i < len ? hexrep[i*2+1] : ' ';
      line[i*3+3] = ' ';
    }
    line[49] = ' ';
    line[50] = '|';
    for (i = 0 ; i < 16 ; i++) {
      if (data[pos+i] >= 0x20 && data[pos+i] < 0x7f) {
        line[51+i] = pos+i < len ? data[pos+i] : ' ';
      } else {
        line[51+i] = pos+i < len ? '.' : ' ';
      }
    }
    line[67] = '|';
    
    line[68] = 0;
    fprintf(stderr, "%08x  %s\n", pos, line);
    hexrep += 32;
  }
  fprintf(stderr, "%08x\n", len);
  free(line);
  free(hexrep_orig);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r15
pushq $0x51
popq %rdi
callq 0x2300
movq %rax, %r14
movq %r15, 0x8(%rsp)
movq %r15, %rdi
movl %ebx, %esi
callq 0x4a14
movq %rax, %r15
movl %ebx, 0x4(%rsp)
testl %ebx, %ebx
jle 0x2696
movl 0x4(%rsp), %r13d
pushq $0x8
popq %rdi
pushq $0x2e
popq %rbx
pushq $0x20
popq %r12
xorl %ebp, %ebp
movq %rbp, %rax
pushq $0x2
popq %rcx
movb $0x20, %dl
movb $0x20, %sil
cmpq %r13, %rax
jae 0x25b8
movb (%r15,%rax,2), %sil
movb %sil, -0x2(%r14,%rcx)
cmpq %r13, %rax
jae 0x25c7
movb 0x1(%r15,%rax,2), %dl
movb %dl, -0x1(%r14,%rcx)
movb $0x20, (%r14,%rcx)
addq $0x3, %rcx
incq %rax
cmpq $0x1a, %rcx
jne 0x25aa
movb $0x20, 0x18(%r14)
movq %rdi, %rax
pushq $0x1b
popq %rcx
movb $0x20, %dl
movb $0x20, %sil
cmpq %r13, %rax
jae 0x25f7
movb (%r15,%rax,2), %sil
movb %sil, -0x2(%r14,%rcx)
cmpq %r13, %rax
jae 0x2606
movb 0x1(%r15,%rax,2), %dl
movb %dl, -0x1(%r14,%rcx)
movb $0x20, (%r14,%rcx)
addq $0x3, %rcx
incq %rax
cmpq $0x33, %rcx
jne 0x25e9
movq %rdi, 0x10(%rsp)
movw $0x7c20, 0x31(%r14)     # imm = 0x7C20
movq 0x8(%rsp), %rax
addq %rbp, %rax
xorl %ecx, %ecx
movzbl (%rax,%rcx), %edx
leal -0x20(%rdx), %esi
cmpb $0x5f, %sil
jb 0x2642
movl %ebx, %edx
leaq (%rcx,%rbp), %rsi
cmpq %r13, %rsi
cmovael %r12d, %edx
movb %dl, 0x33(%r14,%rcx)
incq %rcx
cmpq $0x10, %rcx
jne 0x2633
movw $0x7c, 0x43(%r14)
movq 0x996f(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
leaq 0x5c0c(%rip), %rsi      # 0x827f
movl %ebp, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x2330
addq $0x10, %rbp
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
cmpl 0x4(%rsp), %ebp
jl 0x25a4
movq 0x993b(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
leaq 0x5be2(%rip), %rsi      # 0x8289
movl 0x4(%rsp), %edx
xorl %eax, %eax
callq 0x2330
movq %r14, %rdi
callq 0x2280
movq %r15, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2280
// File: /workspace/github_c_makefile_star2_O1/otrtool[P]otrtool/src/main.c
// Function: verifyOnly
void verifyOnly() {
  vfy_t vfy;
  size_t n;
  static char buffer[65536];
  unsigned long long length;
  unsigned long long position;

  length = atoll(queryGetParam(header, "SZ")) - 522;
  fputs("Verifying otrkey...\n", stderr);
  verifyFile_init(&vfy, 1);
  for (position = 0; position < length; position += n) {
    showProgress(position, length);
    n = MIN(length - position, sizeof(buffer));
    if (fread(buffer, 1, n, file) < n) break;
    verifyFile_data(&vfy, buffer, n);
  }
  if (position < length) {
    if (!feof(file)) PERROR("fread");
    if (!logfilemode) fputc('\n', stderr);
    fputs("file is too short\n", stderr);
  }
  else
    showProgress(1, 0);

  if (fread(buffer, 1, 1, file) > 0)
    fputs("file contains trailing garbage\n", stderr);
  else if (!feof(file))
    PERROR("fread");
  verifyFile_final(&vfy);
  fputs("file is OK\n", stderr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq 0x9c00(%rip), %rdi      # 0xc2e8
leaq 0x62a4(%rip), %rsi      # 0x8993
callq 0x4d54
movq %rax, %rdi
callq 0x2140
movq %rax, %rbx
movq 0x98d2(%rip), %rax      # 0xbfd8
movq (%rax), %rsi
leaq 0x6286(%rip), %rdi      # 0x8996
callq 0x2240
leaq 0xc(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x5f40
addq $-0x20a, %rbx           # imm = 0xFDF6
je 0x2788
xorl %r14d, %r14d
movl $0x10000, %r12d         # imm = 0x10000
leaq 0x9e05(%rip), %r15      # 0xc540
leaq 0xc(%rsp), %r13
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4f42
movq %rbx, %rbp
subq %r14, %rbp
cmpq %r12, %rbp
cmovaeq %r12, %rbp
movq 0x9b71(%rip), %rcx      # 0xc2d0
movq %r15, %rdi
pushq $0x1
popq %rsi
movq %rbp, %rdx
callq 0x2360
cmpq %rbp, %rax
jb 0x279b
movq %r13, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x39ff
addq %rbp, %r14
cmpq %rbx, %r14
jb 0x2740
pushq $0x1
popq %rdi
xorl %esi, %esi
callq 0x4f42
movq 0x983f(%rip), %r14      # 0xbfd8
jmp 0x27d9
movq 0x9b2e(%rip), %rdi      # 0xc2d0
callq 0x2370
testl %eax, %eax
je 0x2843
cmpb $0x0, 0x9ac6(%rip)      # 0xc27c
movq 0x981b(%rip), %r14      # 0xbfd8
jne 0x27ca
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x22c0
movq (%r14), %rsi
leaq 0x61dd(%rip), %rdi      # 0x89b1
callq 0x2240
movq 0x9af0(%rip), %rcx      # 0xc2d0
leaq 0x9d59(%rip), %rdi      # 0xc540
pushq $0x1
popq %rdx
movq %rdx, %rsi
callq 0x2360
testq %rax, %rax
jne 0x2809
movq 0x9ad2(%rip), %rdi      # 0xc2d0
callq 0x2370
testl %eax, %eax
jne 0x2818
jmp 0x284a
movq (%r14), %rsi
leaq 0x61b1(%rip), %rdi      # 0x89c4
callq 0x2240
leaq 0xc(%rsp), %rdi
callq 0x6032
movq (%r14), %rsi
leaq 0x61b8(%rip), %rdi      # 0x89e4
callq 0x2240
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x978e(%rip), %r14      # 0xbfd8
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x22c0
movq (%r14), %rcx
leaq 0x614c(%rip), %rdi      # 0x89ab
pushq $0x5
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x2470
movq (%r14), %rcx
leaq 0x5ec0(%rip), %rdi      # 0x8737
pushq $0x2
popq %rsi
movq %rbx, %rdx
callq 0x2470
xorl %edi, %edi
callq 0x2170
pushq $0x1
popq %rdi
callq 0x2290
// File: /workspace/github_c_makefile_star2_O1/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 %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
leal (%rdx,%rax), %ecx
andl $0x1fffffff, %ecx       # imm = 0x1FFFFFFF
movl %ecx, (%rdi)
cmpl %eax, %ecx
jae 0x3a23
incl 0x4(%r14)
movq %rdx, %rcx
shrq $0x1d, %rcx
addl %ecx, 0x4(%r14)
andq $0x3f, %rax
je 0x3a52
movl $0x40, %r12d
subq %rax, %r12
movq %rdx, %r15
leaq (%r14,%rax), %rdi
addq $0x18, %rdi
subq %r12, %r15
jae 0x3a57
movq %rbx, %rsi
jmp 0x3aa5
movq %rdx, %r15
jmp 0x3a79
leaq 0x18(%r14), %r13
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2160
addq %r12, %rbx
movl $0x40, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x3ab3
cmpq $0x40, %r15
jb 0x3a98
movq %r15, %rdx
andq $-0x40, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3ab3
movq %rax, %rbx
andl $0x3f, %r15d
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2160
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %r12
movl $0x98, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x2100
movaps 0x2b73(%rip), %xmm0     # 0x7010
movups %xmm0, 0x8(%r12)
movq $0x0, (%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x39ff
testq %rbx, %rbx
leaq 0x7d9d(%rip), %r14      # 0xc260
cmoveq %r14, %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4346
movq %r14, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x46a6
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x2b19(%rip), %rsi      # 0x7020
movl $0x1000, %edx           # imm = 0x1000
callq 0x2160
leaq 0x1000(%rbx), %rax
leaq 0x3b01(%rip), %rsi      # 0x8020
movl $0x12, %ecx
movq %rax, %rdi
rep  movsl (%rsi), %es:(%rdi)
xorl %ecx, %ecx
xorl %edx, %edx
xorl %esi, %esi
movl $0x4, %edi
xorl %r8d, %r8d
movl %r8d, %r9d
shll $0x8, %r9d
movzbl (%r15,%rsi), %r8d
orl %r9d, %r8d
incq %rsi
cmpq %r14, %rsi
cmovaeq %rcx, %rsi
decl %edi
jne 0x4537
xorl %r8d, (%rax,%rdx,4)
incq %rdx
cmpq $0x12, %rdx
jne 0x452f
xorl %edx, %edx
movl $0xff, %esi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r8d
xorl %edi, %edi
movl %ecx, %eax
movl %r8d, %ecx
movl %eax, %r8d
movl %ecx, %eax
xorl 0x1000(%rbx,%rdi,4), %eax
movl %eax, %r9d
shrl $0x18, %r9d
movl %eax, %ecx
shrl $0xe, %ecx
andl $0x3fc, %ecx            # imm = 0x3FC
movl 0x400(%rbx,%rcx), %ecx
addl (%rbx,%r9,4), %ecx
movl %eax, %r9d
shrl $0x8, %r9d
andl %esi, %r9d
xorl 0x800(%rbx,%r9,4), %ecx
movl %eax, %r9d
andl %esi, %r9d
addl 0xc00(%rbx,%r9,4), %ecx
xorl %r8d, %ecx
incq %rdi
cmpq $0x10, %rdi
jne 0x4576
xorl 0x1040(%rbx), %ecx
xorl 0x1044(%rbx), %eax
movl %eax, 0x1000(%rbx,%rdx,4)
movl %ecx, 0x1004(%rbx,%rdx,4)
leaq 0x2(%rdx), %rdi
cmpq $0x10, %rdx
movq %rdi, %rdx
jb 0x456c
xorl %edx, %edx
movl $0xff, %esi
movq %rdx, %rdi
shlq $0xa, %rdi
addq %rbx, %rdi
xorl %r8d, %r8d
movl %eax, %r10d
xorl %r9d, %r9d
movl %ecx, %eax
movl %r10d, %ecx
movl %eax, %r10d
movl %ecx, %eax
xorl 0x1000(%rbx,%r9,4), %eax
movl %eax, %r11d
shrl $0x18, %r11d
movl %eax, %ecx
shrl $0xe, %ecx
andl $0x3fc, %ecx            # imm = 0x3FC
movl 0x400(%rbx,%rcx), %ecx
addl (%rbx,%r11,4), %ecx
movl %eax, %r11d
shrl $0x8, %r11d
andl %esi, %r11d
xorl 0x800(%rbx,%r11,4), %ecx
movl %eax, %r11d
andl %esi, %r11d
addl 0xc00(%rbx,%r11,4), %ecx
xorl %r10d, %ecx
incq %r9
cmpq $0x10, %r9
jne 0x4615
xorl 0x1040(%rbx), %ecx
xorl 0x1044(%rbx), %eax
movl %eax, (%rdi,%r8,4)
movl %ecx, 0x4(%rdi,%r8,4)
leaq 0x2(%r8), %r9
cmpq $0xfe, %r8
movq %r9, %r8
jb 0x460a
incq %rdx
cmpq $0x4, %rdx
jne 0x45fd
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
addq $-0x8, %rdx
xorl %ebp, %ebp
movl $0xff, %ecx
movl (%rsi,%rbp), %ebx
movl 0x4(%rsi,%rbp), %eax
movl $0x411, %r8d            # imm = 0x411
movl %eax, %r9d
movl %ebx, %eax
xorl (%rdi,%r8,4), %eax
movl %eax, %r10d
shrl $0x18, %r10d
movl %eax, %r11d
shrl $0xe, %r11d
andl $0x3fc, %r11d           # imm = 0x3FC
movl 0x400(%rdi,%r11), %ebx
addl (%rdi,%r10,4), %ebx
movl %eax, %r10d
shrl $0x8, %r10d
andl %ecx, %r10d
xorl 0x800(%rdi,%r10,4), %ebx
movl %eax, %r10d
andl %ecx, %r10d
addl 0xc00(%rdi,%r10,4), %ebx
xorl %r9d, %ebx
leaq -0x1(%r8), %r9
addq $-0x400, %r8            # imm = 0xFC00
cmpq $0x2, %r8
movq %r9, %r8
ja 0x46c1
xorl 0x1004(%rdi), %ebx
xorl 0x1000(%rdi), %eax
movl %eax, %r8d
shrl $0x10, %r8d
movl %eax, %r9d
shrl $0x18, %r9d
movb %r9b, 0x3(%rsi,%rbp)
movb %r8b, 0x2(%rsi,%rbp)
movb %ah, 0x1(%rsi,%rbp)
movb %al, (%rsi,%rbp)
movl %ebx, %eax
shrl $0x10, %eax
movl %ebx, %r8d
shrl $0x18, %r8d
movb %r8b, 0x7(%rsi,%rbp)
movb %al, 0x6(%rsi,%rbp)
movb %bh, 0x5(%rsi,%rbp)
movb %bl, 0x4(%rsi,%rbp)
addq $0x8, %rbp
cmpq %rdx, %rbp
jbe 0x46b4
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
movl (%rcx), %ebx
movl 0x4(%rcx), %eax
addq $-0x8, %rdx
xorl %ebp, %ebp
movl $0xff, %r8d
movl %ebx, %r10d
xorl (%rsi,%rbp), %r10d
xorl 0x4(%rsi,%rbp), %eax
xorl %r9d, %r9d
movl %eax, %ebx
movl %r10d, %eax
movl %ebx, %r10d
movl %eax, %ebx
xorl 0x1000(%rdi,%r9,4), %ebx
movl %ebx, %r11d
shrl $0x18, %r11d
movl %ebx, %eax
shrl $0xe, %eax
andl $0x3fc, %eax            # imm = 0x3FC
movl 0x400(%rdi,%rax), %eax
addl (%rdi,%r11,4), %eax
movl %ebx, %r11d
shrl $0x8, %r11d
andl %r8d, %r11d
xorl 0x800(%rdi,%r11,4), %eax
movl %ebx, %r11d
andl %r8d, %r11d
addl 0xc00(%rdi,%r11,4), %eax
xorl %r10d, %eax
incq %r9
cmpq $0x10, %r9
jne 0x47a2
xorl 0x1040(%rdi), %eax
xorl 0x1044(%rdi), %ebx
movl %ebx, %r9d
shrl $0x10, %r9d
movl %ebx, %r10d
shrl $0x18, %r10d
movb %r10b, 0x3(%rsi,%rbp)
movb %r9b, 0x2(%rsi,%rbp)
movb %bh, 0x1(%rsi,%rbp)
movb %bl, (%rsi,%rbp)
movl %eax, %r11d
shrl $0x10, %r11d
movl %eax, %r14d
shrl $0x18, %r14d
movb %r14b, 0x7(%rsi,%rbp)
movb %r11b, 0x6(%rsi,%rbp)
movb %ah, 0x5(%rsi,%rbp)
movb %al, 0x4(%rsi,%rbp)
addq $0x8, %rbp
cmpq %rdx, %rbp
jbe 0x478f
movb %r10b, 0x3(%rcx)
movb %r9b, 0x2(%rcx)
movb %bh, 0x1(%rcx)
movb %bl, (%rcx)
movb %r14b, 0x7(%rcx)
movb %r11b, 0x6(%rcx)
movb %ah, 0x5(%rcx)
movb %al, 0x4(%rcx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/otrtool[P]otrtool/src/main.c
// Function: bin2hex
char * bin2hex(void *data_, int len) {
  unsigned char *data = data_;
  unsigned char *result = malloc(sizeof(char) * len * 2 + 1);
  result[len * 2] = 0;
  int foo;
  for (len-- ; len >= 0 ; len--) {
    foo = data[len] % 16;
    result[len*2 + 1] = foo > 9 ? 0x37 + foo : 0x30 + foo;
    foo = data[len] >> 4;
    result[len*2] = foo > 9 ? 0x37 + foo : 0x30 + foo;
  }
  return (char*)result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %r14
leaq 0x1(,%r14,2), %rdi
callq 0x2300
movb $0x0, (%rax,%r14,2)
testl %r14d, %r14d
jle 0x4a8b
movl %ebp, %ecx
incq %rcx
movb -0x2(%rbx,%rcx), %dl
movl %edx, %esi
andb $0xf, %sil
leal 0x37(%rsi), %edi
leal 0x30(%rsi), %r8d
cmpb $0xa, %sil
movzbl %dil, %esi
movzbl %r8b, %edi
cmovael %esi, %edi
movl %edx, %esi
shrb $0x4, %sil
leal 0x37(%rsi), %r8d
orb $0x30, %sil
cmpb $-0x60, %dl
movzbl %r8b, %edx
movzbl %sil, %esi
cmovael %edx, %esi
movb %dil, -0x3(%rax,%rcx,2)
movb %sil, -0x4(%rax,%rcx,2)
decq %rcx
cmpq $0x1, %rcx
jg 0x4a3c
popq %rbx
popq %r14
popq %rbp
retq