LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/compile_x86.c
// Function: get_setcode
x86_op_t get_setcode(op_t op) {
    switch(op) {
        case OP_EQ: return X86_OP_sete;
        case OP_NE: return X86_OP_setne;
        case OP_LT: return X86_OP_setl;
        case OP_LE: return X86_OP_setle;
        case OP_GT: return X86_OP_setg;
        case OP_GE: return X86_OP_setge;
        default:
            return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x5, %eax
ja 0x11852
movq -0x10(%rbp), %rax
leaq 0x449d(%rip), %rcx      # 0x15cb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xd, -0x4(%rbp)
jmp 0x11859
movl $0xe, -0x4(%rbp)
jmp 0x11859
movl $0xf, -0x4(%rbp)
jmp 0x11859
movl $0x10, -0x4(%rbp)
jmp 0x11859
movl $0x11, -0x4(%rbp)
jmp 0x11859
movl $0x12, -0x4(%rbp)
jmp 0x11859
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/compile_x86.c
// Function: get_opcode
x86_op_t get_opcode(op_t op) {
    switch(op) {
        case OP_PLUS: return X86_OP_add;
        case OP_MINUS: return X86_OP_sub;
        case OP_MUL: return X86_OP_imul;
        case OP_DIV: return X86_OP_idiv;
        case OP_AND: return X86_OP_and;
        case OP_OR: return X86_OP_or;
        default:
            return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0xb, %rax
ja 0x118be
movq -0x10(%rbp), %rax
leaq 0x4449(%rip), %rcx      # 0x15cc8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x2, -0x4(%rbp)
jmp 0x118c5
movl $0x3, -0x4(%rbp)
jmp 0x118c5
movl $0x4, -0x4(%rbp)
jmp 0x118c5
movl $0x5, -0x4(%rbp)
jmp 0x118c5
movl $0x8, -0x4(%rbp)
jmp 0x118c5
movl $0x9, -0x4(%rbp)
jmp 0x118c5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/compile_x86.c
// Function: get_branch_opcode
x86_op_t get_branch_opcode(op_t op) {
    switch(op) {
        case OP_JUMP: return X86_OP_jmp;
        case OP_JUMP0: return X86_OP_jz;
        case OP_JUMP1: return X86_OP_jnz;
        case OP_JG: return X86_OP_jg;
        case OP_JNE: return X86_OP_jne;
        case OP_LABEL: return X86_OP_label;
        default:
            return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $-0x10, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x5, %eax
ja 0x11932
movq -0x10(%rbp), %rax
leaq 0x4405(%rip), %rcx      # 0x15cf8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x19, -0x4(%rbp)
jmp 0x11939
movl $0x16, -0x4(%rbp)
jmp 0x11939
movl $0x15, -0x4(%rbp)
jmp 0x11939
movl $0x17, -0x4(%rbp)
jmp 0x11939
movl $0x18, -0x4(%rbp)
jmp 0x11939
movl $0x13, -0x4(%rbp)
jmp 0x11939
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12ea9
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x12e62
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x18(%rcx)
movb %al, -0x19(%rbp)
je 0x12e62
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
xorl %eax, %eax
cmpl $0x1, 0x14(%rcx)
movb %al, -0x19(%rbp)
jne 0x12e62
movq -0x18(%rbp), %rax
cmpl $0xc, (%rax)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x12e6b
jmp 0x12e9a
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x10740
jmp 0x12e26
jmp 0x12e9c
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x12e0f
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/utils/sort/test/test_sort.c
// Function: swap_int
void swap_int(void *args, int i, int j) {
    int *args_nums = (int *)args;

    int temp = args_nums[i];
    args_nums[i] = args_nums[j];
    args_nums[j] = temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x8e5(%rip), %rax       # 0x2004
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movq 0x955(%rip), %rax       # 0x2080
movq %rax, -0x30(%rbp)
movq 0x952(%rip), %rax       # 0x2088
movq %rax, -0x28(%rbp)
movq 0x94f(%rip), %rax       # 0x2090
movq %rax, -0x20(%rbp)
movq 0x94c(%rip), %rax       # 0x2098
movq %rax, -0x18(%rbp)
leaq -0x30(%rbp), %rdx
xorl %edi, %edi
movl $0x7, %esi
leaq -0xd2(%rip), %rcx       # 0x1690
leaq -0xa9(%rip), %r8        # 0x16c0
callq 0x1470
movl $0x0, -0x34(%rbp)
cmpl $0x8, -0x34(%rbp)
jge 0x17c5
movslq -0x34(%rbp), %rax
movl -0x30(%rbp,%rax,4), %eax
movl -0x34(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
je 0x17b8
movl -0x34(%rbp), %esi
movslq -0x34(%rbp), %rax
movl -0x30(%rbp,%rax,4), %edx
movl -0x34(%rbp), %ecx
addl $0x1, %ecx
leaq 0x8fb(%rip), %rdi       # 0x20a0
movb $0x0, %al
callq 0x12f0
leaq 0x855(%rip), %rax       # 0x2008
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x17ba
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1775
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movb -0x21(%rbp), %dl
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x28(%rbp), %edx
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x755(%rip), %rax       # 0x2004
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl 0x846(%rip), %eax       # 0x2100
movl %eax, -0xb(%rbp)
movw 0x840(%rip), %ax        # 0x2104
movw %ax, -0x7(%rbp)
movb 0x838(%rip), %al        # 0x2106
movb %al, -0x5(%rbp)
movq 0x838(%rip), %rax       # 0x2110
movq %rax, -0x30(%rbp)
movq 0x835(%rip), %rax       # 0x2118
movq %rax, -0x28(%rbp)
movq 0x832(%rip), %rax       # 0x2120
movq %rax, -0x20(%rbp)
movl 0x830(%rip), %eax       # 0x2128
movl %eax, -0x18(%rbp)
leaq -0xb(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movl 0x81b(%rip), %eax       # 0x212c
movl %eax, -0x47(%rbp)
movw 0x815(%rip), %ax        # 0x2130
movw %ax, -0x43(%rbp)
movb 0x80d(%rip), %al        # 0x2132
movb %al, -0x41(%rbp)
leaq -0x40(%rbp), %rdx
xorl %edi, %edi
movl $0x6, %esi
leaq -0x2aa(%rip), %rcx      # 0x1690
leaq -0x281(%rip), %r8       # 0x16c0
callq 0x1470
movl $0x0, -0x4c(%rbp)
cmpl $0x7, -0x4c(%rbp)
jge 0x19c0
movslq -0x4c(%rbp), %rax
movsbl -0xb(%rbp,%rax), %eax
movslq -0x4c(%rbp), %rcx
movsbl -0x47(%rbp,%rcx), %ecx
cmpl %ecx, %eax
jne 0x197b
movslq -0x4c(%rbp), %rax
movl -0x30(%rbp,%rax,4), %eax
movl -0x4c(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
je 0x19b3
movl -0x4c(%rbp), %esi
movslq -0x4c(%rbp), %rax
movsbl -0xb(%rbp,%rax), %edx
movslq -0x4c(%rbp), %rax
movl -0x30(%rbp,%rax,4), %ecx
movslq -0x4c(%rbp), %rax
movsbl -0x47(%rbp,%rax), %r8d
leaq 0x71b(%rip), %rdi       # 0x20bb
movb $0x0, %al
callq 0x12f0
leaq 0x65a(%rip), %rax       # 0x2008
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x19b5
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x194d
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x61e(%rip), %rax       # 0x2004
movl (%rax), %eax
movl %eax, -0x8(%rbp)
callq 0x1710
andl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x1a0c
leaq 0x6d4(%rip), %rdi       # 0x20d7
movb $0x0, %al
callq 0x13b0
jmp 0x1a1a
leaq 0x6da(%rip), %rdi       # 0x20ed
movb $0x0, %al
callq 0x12f0
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x88, %rsp
movl $0x0, 0x84(%rsp)
movl %edi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
cmpl $0x2, 0x80(%rsp)
jge 0x11f6
leaq 0x2e39(%rip), %rdi      # 0x4018
movb $0x0, %al
callq 0x1060
movl $0x0, 0x84(%rsp)
jmp 0x12fe
movq 0x78(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rsi
leaq 0x2e26(%rip), %rdi      # 0x4036
movb $0x0, %al
callq 0x1060
leaq 0x2e29(%rip), %rax      # 0x4047
movq %rax, 0x20(%rsp)
leaq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
leaq 0x2e04(%rip), %rax      # 0x4049
movq %rax, 0x40(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, 0x48(%rsp)
movl $0x0, 0x50(%rsp)
movq $0x0, 0x58(%rsp)
movq 0x70(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x2, %edx
leaq 0x1c(%rsp), %rcx
callq 0x2570
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x12d7
movsd 0x2d7d(%rip), %xmm0     # 0x4010
movsd %xmm0, 0x68(%rsp)
movsd 0x2d67(%rip), %xmm0     # 0x4008
movsd %xmm0, 0x60(%rsp)
movq 0x10(%rsp), %rdi
callq 0x19d0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
leaq 0x2d87(%rip), %rdi      # 0x404b
movb $0x1, %al
callq 0x1060
movq 0x10(%rsp), %rdi
callq 0x13c0
jmp 0x12f3
movl 0x1c(%rsp), %esi
subl $0x1, %esi
leaq 0x2d73(%rip), %rdi      # 0x4058
leaq 0x2d49(%rip), %rdx      # 0x4035
movb $0x0, %al
callq 0x1060
movl $0x0, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x10(%rbp)
movq $0xb, -0x18(%rbp)
movl $0x18, %edi
callq 0x1030
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x13d0
jmp 0x11d5
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x12a4
movq -0x18(%rbp), %rax
movl -0x4(%rbp), %ecx
sarl %ecx
movslq %ecx, %rcx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12e0
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x13f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1271
movq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0xc(%rbp), %rdx
callq 0x1480
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1294
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x18, %esi
callq 0x1040
jmp 0x12d2
movq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1a20
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1050
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1296
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x11e4
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x12c9
movq -0x48(%rbp), %rdi
callq 0x2410
movq -0x48(%rbp), %rdi
movl $0x18, %esi
callq 0x1040
movl -0x10(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x1090
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1465
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x24d0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x1443
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1463
cmpl $0x0, -0x24(%rbp)
jle 0x1457
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1461
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x146d
jmp 0x1463
jmp 0x1410
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x24c2
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2490
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1050
jmp 0x24b6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x24b8
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x2468
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x10f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x1d4c00, %edi         # imm = 0x1D4C00
callq 0x10b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x88, %edx
callq 0x1060
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x1120
movq -0x10(%rbp), %rdi
movq -0x88(%rbp), %rsi
movl -0x8c(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %r9
movl $0x2, %ecx
xorl %r8d, %r8d
movl $0x320, (%rsp)          # imm = 0x320
movl $0x258, 0x8(%rsp)       # imm = 0x258
movl $0x20, 0x10(%rsp)
movl $0xc80, 0x18(%rsp)      # imm = 0xC80
callq 0x1170
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x144b
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x143e
movl -0xc(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x10(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
xorl %eax, %eax
cmpl -0x24(%rbp), %eax
jg 0x1431
cmpl $0x320, -0x24(%rbp)     # imm = 0x320
jae 0x1431
xorl %eax, %eax
cmpl -0x28(%rbp), %eax
jg 0x1431
cmpl $0x258, -0x28(%rbp)     # imm = 0x258
jae 0x1431
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
imull $0x320, -0x28(%rbp), %ecx # imm = 0x320
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movl $0xff0000, (%rax,%rcx,4) # imm = 0xFF0000
jmp 0x1433
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x13db
jmp 0x1440
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x13cc
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq -0x18(%rbp), %rax
andq $0x1fffffff, %rax       # imm = 0x1FFFFFFF
movq -0x8(%rbp), %rcx
movl %eax, (%rcx)
cmpl -0x1c(%rbp), %eax
jae 0x2612
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rdx
shrq $0x1d, %rdx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addq %rdx, %rcx
movl %ecx, 0x4(%rax)
movl -0x1c(%rbp), %eax
andl $0x3f, %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x26b9
movl $0x40, %eax
subq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x266f
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
addq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2170
jmp 0x26fa
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
addq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x2170
movq -0x10(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
movl $0x40, %edx
callq 0x2700
cmpq $0x40, -0x18(%rbp)
jb 0x26e5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
andq $-0x40, %rdx
callq 0x2700
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
andq $0x3f, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2170
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xb0(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x2110
leaq -0xb0(%rbp), %rdi
callq 0x2580
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0xb0(%rbp), %rdi
callq 0x25d0
cmpq $0x0, -0x18(%rbp)
je 0x3a0e
movq -0x18(%rbp), %rax
movq %rax, -0xc0(%rbp)
jmp 0x3a1e
leaq 0x986b(%rip), %rax      # 0xd280
movq %rax, -0xc0(%rbp)
jmp 0x3a1e
movq -0xc0(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x3720
leaq 0x983a(%rip), %rax      # 0xd280
addq $0xc0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/otrtool[P]otrtool/src/blowfish.c
// Function: F
static uint32_t F(const bf_state_t *st, uint32_t xL)
{
  uint8_t a, b, c, d;

  a = (xL >> 24) & 0xFF;
  b = (xL >> 16) & 0xFF;
  c = (xL >> 8) & 0xFF;
  d = xL & 0xFF;

  return ((st->S[0][a] + st->S[1][b]) ^ st->S[2][c]) + st->S[3][d];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, -0xd(%rbp)
movl -0xc(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, -0xe(%rbp)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, -0xf(%rbp)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl -0xd(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movzbl -0xe(%rbp), %edx
addl 0x400(%rcx,%rdx,4), %eax
movq -0x8(%rbp), %rcx
movzbl -0xf(%rbp), %edx
xorl 0x800(%rcx,%rdx,4), %eax
movq -0x8(%rbp), %rcx
movzbl -0x10(%rbp), %edx
addl 0xc00(%rcx,%rdx,4), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x8, %rcx
cmpq %rcx, %rax
ja 0x3ec9
movq -0x20(%rbp), %rdi
addq -0x30(%rbp), %rdi
callq 0x3ed0
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
addq -0x30(%rbp), %rdi
addq $0x4, %rdi
callq 0x3ed0
movl %eax, -0x28(%rbp)
movl $0x11, -0x38(%rbp)
cmpl $0x1, -0x38(%rbp)
jle 0x3e60
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x38(%rbp), %rdx
xorl 0x1000(%rcx,%rdx,4), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x3d30
xorl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x3e55
movl -0x38(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x3e14
jmp 0x3e62
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x8(%rbp), %rcx
xorl 0x1004(%rcx), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
xorl 0x1000(%rcx), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
addq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x3f10
movq -0x20(%rbp), %rdi
addq -0x30(%rbp), %rdi
addq $0x4, %rdi
movl -0x28(%rbp), %esi
callq 0x3f10
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
jmp 0x3dd4
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3ed0
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rdi
addq $0x4, %rdi
callq 0x3ed0
movl %eax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x8, %rcx
cmpq %rcx, %rax
ja 0x40a3
movq -0x28(%rbp), %rdi
addq -0x48(%rbp), %rdi
callq 0x3ed0
xorl -0x3c(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rdi
addq -0x48(%rbp), %rdi
addq $0x4, %rdi
callq 0x3ed0
xorl -0x40(%rbp), %eax
movl %eax, -0x38(%rbp)
movl $0x0, -0x50(%rbp)
cmpl $0x10, -0x50(%rbp)
jge 0x402e
movl -0x34(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x50(%rbp), %rdx
xorl 0x1000(%rcx,%rdx,4), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x3d30
xorl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x4023
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x3fe2
jmp 0x4030
movl -0x34(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movq -0x8(%rbp), %rcx
xorl 0x1040(%rcx), %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
movq -0x8(%rbp), %rcx
xorl 0x1044(%rcx), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rdi
addq -0x48(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x3f10
movq -0x28(%rbp), %rdi
addq -0x48(%rbp), %rdi
addq $0x4, %rdi
movl -0x38(%rbp), %esi
callq 0x3f10
movl -0x34(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
jmp 0x3f9c
movq -0x30(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x3f10
movq -0x30(%rbp), %rdi
addq $0x4, %rdi
movl -0x40(%rbp), %esi
callq 0x3f10
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/otrtool[P]otrtool/src/blowfish.c
// Function: bf_cbc_decrypt
void bf_cbc_decrypt(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, ivLn, ivRn;
  size_t i;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3ed0
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rdi
addq $0x4, %rdi
callq 0x3ed0
movl %eax, -0x40(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x8, %rcx
cmpq %rcx, %rax
ja 0x4229
movq -0x28(%rbp), %rdi
addq -0x50(%rbp), %rdi
callq 0x3ed0
movl %eax, -0x44(%rbp)
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rdi
addq -0x50(%rbp), %rdi
addq $0x4, %rdi
callq 0x3ed0
movl %eax, -0x48(%rbp)
movl %eax, -0x38(%rbp)
movl $0x11, -0x58(%rbp)
cmpl $0x1, -0x58(%rbp)
jle 0x41ae
movl -0x34(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x58(%rbp), %rdx
xorl 0x1000(%rcx,%rdx,4), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x3d30
xorl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x41a3
movl -0x58(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x4162
jmp 0x41b0
movl -0x34(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movq -0x8(%rbp), %rcx
xorl 0x1004(%rcx), %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
movq -0x8(%rbp), %rcx
xorl 0x1000(%rcx), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rdi
addq -0x50(%rbp), %rdi
movl -0x34(%rbp), %esi
xorl -0x3c(%rbp), %esi
callq 0x3f10
movq -0x28(%rbp), %rdi
addq -0x50(%rbp), %rdi
addq $0x4, %rdi
movl -0x38(%rbp), %esi
xorl -0x40(%rbp), %esi
callq 0x3f10
movl -0x44(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x50(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
jmp 0x411c
movq -0x30(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x3f10
movq -0x30(%rbp), %rdi
addq $0x4, %rdi
movl -0x40(%rbp), %esi
callq 0x3f10
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x42e8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x2030
movl (%rax), %eax
movl %eax, -0xc(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x8, -0x30(%rbp)
movq 0x8c97(%rip), %rax      # 0xcfd8
movq %rax, -0xf0(%rbp)
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2310
movq -0xf0(%rbp), %rax
movq (%rax), %rsi
leaq 0x6440(%rip), %rdi      # 0xa7a9
callq 0x2240
movl -0xc(%rbp), %eax
movl %eax, -0xe4(%rbp)
callq 0x2030
movl -0xe4(%rbp), %ecx
movl %ecx, (%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x2180
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x0, %rdi
shlq %rdi
addq $0x1, %rdi
callq 0x2300
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x4488
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %edx, -0x24(%rbp)
cmpl $0x9, -0x24(%rbp)
jle 0x441a
movl -0x24(%rbp), %eax
addl $0x37, %eax
movl %eax, -0x28(%rbp)
jmp 0x4423
movl -0x24(%rbp), %eax
addl $0x30, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movb %al, %dl
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
shll %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %eax
sarl $0x4, %eax
movl %eax, -0x24(%rbp)
cmpl $0x9, -0x24(%rbp)
jle 0x445d
movl -0x24(%rbp), %eax
addl $0x37, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4466
movl -0x24(%rbp), %eax
addl $0x30, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movb %al, %dl
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x43e8
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/otrtool[P]otrtool/src/main.c
// Function: hex2bin
void * hex2bin(char *data_) {
  int len = strlen(data_) / 2;
  unsigned char *data = (unsigned char*)data_;
  // never tested with lowercase letters!
  unsigned char *result = malloc(sizeof(char) * len + 1);
  int foo, bar;
  result[len] = 0;
  for (len-- ; len >= 0 ; len--) {
    foo = data[len*2];
    if (foo < 0x41) {
      // is a digit
      bar = foo - 0x30;
    } else if (foo < 0x61) {
      // is a uppercase letter
      bar = foo - 0x37;
    } else {
      // is a lowercase letter
      bar = foo - 0x57;
    }
    result[len] = bar << 4;
    
    foo = data[len*2 + 1];
    if (foo < 0x41) {
      // is a digit
      bar = foo - 0x30;
    } else if (foo < 0x61) {
      // is a uppercase letter
      bar = foo - 0x37;
    } else {
      // is a lowercase letter
      bar = foo - 0x57;
    }
    result[len] += bar;
  }
  return (void*)result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20c0
shrq %rax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x0, %rdi
addq $0x1, %rdi
callq 0x2300
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x45af
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
cmpl $0x41, -0x24(%rbp)
jge 0x451b
movl -0x24(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x28(%rbp)
jmp 0x4537
cmpl $0x61, -0x24(%rbp)
jge 0x452c
movl -0x24(%rbp), %eax
subl $0x37, %eax
movl %eax, -0x28(%rbp)
jmp 0x4535
movl -0x24(%rbp), %eax
subl $0x57, %eax
movl %eax, -0x28(%rbp)
jmp 0x4537
movl -0x28(%rbp), %eax
shll $0x4, %eax
movb %al, %dl
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
shll %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
cmpl $0x41, -0x24(%rbp)
jge 0x4571
movl -0x24(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x28(%rbp)
jmp 0x458d
cmpl $0x61, -0x24(%rbp)
jge 0x4582
movl -0x24(%rbp), %eax
subl $0x37, %eax
movl %eax, -0x28(%rbp)
jmp 0x458b
movl -0x24(%rbp), %eax
subl $0x57, %eax
movl %eax, -0x28(%rbp)
jmp 0x458d
movl -0x28(%rbp), %esi
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %edx
addl %esi, %edx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x44ed
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/otrtool[P]otrtool/src/main.c
// Function: queryGetParam
char * queryGetParam(char *query, char *name) {
  char *begin = strchr(query, '&');
  char *end;
  int nameLen = strlen(name);
  
  while (begin != NULL) {
    begin++;
    if (strncmp(begin, name, nameLen) == 0 && begin[nameLen] == '=') {
      begin += nameLen + 1;
      end = strchr(begin, '&');
      if (end == NULL)
        end = begin + strlen(begin);
      char *result = malloc(end - begin + 1);
      strncpy(result, begin, end - begin);
      result[end - begin] = 0;
      return result;
    }
    begin = strchr(begin, '&');
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x26, %esi
callq 0x2090
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20c0
movl %eax, -0x2c(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4b04
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x2c(%rbp), %rdx
callq 0x20f0
cmpl $0x0, %eax
jne 0x4aed
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3d, %eax
jne 0x4aed
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x26, %esi
callq 0x2090
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4aa0
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20c0
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
subq %rax, %rdi
addq $0x1, %rdi
callq 0x2300
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rax
subq %rax, %rdx
callq 0x2100
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rdx
subq %rdx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4b0c
movq -0x20(%rbp), %rdi
movl $0x26, %esi
callq 0x2090
movq %rax, -0x20(%rbp)
jmp 0x4a0e
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/otrtool[P]otrtool/src/main.c
// Function: quote
void quote(char *message) {
  char line[LINE_LENGTH + 1];
  line[0] = '>';
  line[1] = ' ';
  int index = 2;
  
  while (*message != 0) {
    if (*message < 0x20 || *message > 0x7E) {
      line[index++] = ' ';
    } else {
      line[index++] = *message;
    }
    if (index == LINE_LENGTH) {
      line[index++] = '\n';
      fwrite(line, index, 1, stderr);
      line[0] = '>';
      line[1] = ' ';
      index = 2;
    }
    message++;
  }
  line[index++] = '\n';
  if (index != 3) fwrite(line, index, 1, stderr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movb $0x3e, -0x60(%rbp)
movb $0x20, -0x5f(%rbp)
movl $0x2, -0x64(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x4be2
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jl 0x4b63
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
jle 0x4b77
movl -0x64(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x64(%rbp)
cltq
movb $0x20, -0x60(%rbp,%rax)
jmp 0x4b8e
movq -0x8(%rbp), %rax
movb (%rax), %cl
movl -0x64(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x64(%rbp)
cltq
movb %cl, -0x60(%rbp,%rax)
cmpl $0x50, -0x64(%rbp)
jne 0x4bd1
movl -0x64(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x64(%rbp)
cltq
movb $0xa, -0x60(%rbp,%rax)
leaq -0x60(%rbp), %rdi
movslq -0x64(%rbp), %rsi
movq 0x8423(%rip), %rax      # 0xcfd8
movq (%rax), %rcx
movl $0x1, %edx
callq 0x2470
movb $0x3e, -0x60(%rbp)
movb $0x20, -0x5f(%rbp)
movl $0x2, -0x64(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x4b3b
movl -0x64(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x64(%rbp)
cltq
movb $0xa, -0x60(%rbp,%rax)
cmpl $0x3, -0x64(%rbp)
je 0x4c16
leaq -0x60(%rbp), %rdi
movslq -0x64(%rbp), %rsi
movq 0x83cf(%rip), %rax      # 0xcfd8
movq (%rax), %rcx
movl $0x1, %edx
callq 0x2470
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/otrtool[P]otrtool/src/main.c
// Function: dumpQuerystring
void dumpQuerystring(char *query) {
  char line[LINE_LENGTH + 1];
  int index = 0;

  if (*query == '&') {
    line[0] = '&';
    index++;
    query++;
  }

  for (; *query; query++) {
    if (*query == '&') {
      line[index] = '\n';
      fwrite(line, index + 1, 1, stderr);
      index = 0;
    }
    line[index] = *query;

    index++;
    if (index == LINE_LENGTH) {
      line[index] = '\n';
      fwrite(line, index + 1, 1, stderr);
      line[0] = ' ';
      index = 1;
    }
  }
  line[index] = '\n';
  if (index != LINE_LENGTH) fwrite(line, index + 1, 1, stderr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x64(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x26, %eax
jne 0x4c58
movb $0x26, -0x60(%rbp)
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x4c5a
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x4d09
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x26, %eax
jne 0x4ca4
movslq -0x64(%rbp), %rax
movb $0xa, -0x60(%rbp,%rax)
leaq -0x60(%rbp), %rdi
movl -0x64(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
movq 0x8348(%rip), %rax      # 0xcfd8
movq (%rax), %rcx
movl $0x1, %edx
callq 0x2470
movl $0x0, -0x64(%rbp)
movq -0x8(%rbp), %rax
movb (%rax), %cl
movslq -0x64(%rbp), %rax
movb %cl, -0x60(%rbp,%rax)
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
cmpl $0x50, -0x64(%rbp)
jne 0x4cf6
movslq -0x64(%rbp), %rax
movb $0xa, -0x60(%rbp,%rax)
leaq -0x60(%rbp), %rdi
movl -0x64(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
movq 0x82fa(%rip), %rax      # 0xcfd8
movq (%rax), %rcx
movl $0x1, %edx
callq 0x2470
movb $0x20, -0x60(%rbp)
movl $0x1, -0x64(%rbp)
jmp 0x4cf8
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x4c5a
movslq -0x64(%rbp), %rax
movb $0xa, -0x60(%rbp,%rax)
cmpl $0x50, -0x64(%rbp)
je 0x4d39
leaq -0x60(%rbp), %rdi
movl -0x64(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
movq 0x82ac(%rip), %rax      # 0xcfd8
movq (%rax), %rcx
movl $0x1, %edx
callq 0x2470
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/otrtool[P]otrtool/src/main.c
// Function: createThread
thread_t createThread(void *(*start_routine)(void *), void *arg) {
  pthread_t tid;
  errno = pthread_create(&tid, NULL, start_routine, arg);
  if (errno != 0) PERROR("pthread_create");
  return tid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2430
movl %eax, -0x1c(%rbp)
callq 0x2030
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
callq 0x2030
cmpl $0x0, (%rax)
je 0x52a9
jmp 0x524e
movq 0x7d83(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x55b7(%rip), %rsi      # 0xa816
movb $0x0, %al
callq 0x2330
movq 0x7d6b(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x50f1(%rip), %rsi      # 0xa368
movb $0x0, %al
callq 0x2330
movq 0x7d53(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x551a(%rip), %rsi      # 0xa7a9
movb $0x0, %al
callq 0x2330
xorl %eax, %eax
movl %eax, %edi
callq 0x2180
movl $0x1, %edi
callq 0x2290
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/otrtool[P]otrtool/src/main.c
// Function: joinThread
void *joinThread(thread_t tid) {
  void *res;
  errno = pthread_join(tid, &res);
  if (errno != 0) PERROR("pthread_join");
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x21b0
movl %eax, -0x14(%rbp)
callq 0x2030
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
callq 0x2030
cmpl $0x0, (%rax)
je 0x534d
jmp 0x52f2
movq 0x7cdf(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x5513(%rip), %rsi      # 0xa816
movb $0x0, %al
callq 0x2330
movq 0x7cc7(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x505c(%rip), %rsi      # 0xa377
movb $0x0, %al
callq 0x2330
movq 0x7caf(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
leaq 0x5476(%rip), %rsi      # 0xa7a9
movb $0x0, %al
callq 0x2330
xorl %eax, %eax
movl %eax, %edi
callq 0x2180
movl $0x1, %edi
callq 0x2290
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)