LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/pahihu[P]mixal/run.c
// Function: save_memory
static void save_memory(const char *path, Cell *store, unsigned size)
{
    FILE *fout;
    size_t cells_written;

    fout = fopen(path, "wb");
    if (NULL == fout)
        error("Cannot open %s", path);
    cells_written = fwrite(store, sizeof(Cell), size, fout);
    fclose(fout);
    if (cells_written != size)
        error("Cannot write %d cells to %s", size, path);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
leaq 0x3357(%rip), %rsi      # 0xa311
callq 0x3250
movq %rax, %r15
testq %rax, %rax
jne 0x6fd8
leaq 0x3346(%rip), %rdi      # 0xa314
movq %r14, %rsi
xorl %eax, %eax
callq 0x5700
movl %ebx, %r13d
pushq $0x8
popq %rsi
movq %r12, %rdi
movq %r13, %rdx
movq %r15, %rcx
callq 0x32a0
movq %rax, %r12
movq %r15, %rdi
callq 0x30f0
cmpq %r13, %r12
jne 0x7006
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x3316(%rip), %rdi      # 0xa323
movl %ebx, %esi
movq %r14, %rdx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5700
// File: /workspace/github_c_makefile_star2_O2/pahihu[P]mixal/run.c
// Function: save_state
static void save_state(void)
{
    Cell psw;
    Byte flags;
    int i;

    control_memory[9] = r[A];
    control_memory[8] = r[X];
    for (i = 1; i < 7; i++)
        control_memory[8 - i] = r[i];

    flags = 0;
    if (overflow)
        flags += 8;
    flags += 1 + SIGN(comparison_indicator);

    psw = set_field(r[J], make_field_spec(4, 5), zero);
    psw = set_byte(flags, 3, psw);
    psw = set_field(address_to_cell(pc), make_field_spec(1, 2), psw);

    control_memory[1] = psw;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x9a96(%rip), %rcx      # 0x10d60
movq 0x9aef(%rip), %rax      # 0x10dc0
movq %rcx, 0x48(%rax)
movq 0x9abc(%rip), %rcx      # 0x10d98
movq %rcx, 0x40(%rax)
pushq $0x7
popq %rcx
leaq 0x9a7e(%rip), %rdx      # 0x10d68
cmpq $0x1, %rcx
je 0x7300
movq (%rdx), %rsi
movq %rsi, (%rax,%rcx,8)
decq %rcx
addq $0x8, %rdx
jmp 0x72ea
movl 0x9a3e(%rip), %eax      # 0x10d44
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
incl %ecx
xorl %edx, %edx
testl %eax, %eax
cmovsl %edx, %ecx
leaq 0x8823(%rip), %rax      # 0xfb40
xorl %edx, %edx
cmpl $0x0, (%rax)
setne %dl
leal (%rcx,%rdx,8), %ebx
movq 0x9a71(%rip), %r14      # 0x10da0
pushq $0x4
popq %rdi
pushq $0x5
popq %rsi
callq 0x3610
movq %r14, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x3685
pushq $0x3
popq %rsi
movl %ebx, %edi
movq %rax, %rdx
callq 0x363f
movq %rax, %rbx
movl 0x9a54(%rip), %edi      # 0x10db0
callq 0x3e11
movq %rax, %r14
pushq $0x1
popq %rdi
pushq $0x2
popq %rsi
callq 0x3610
movq %r14, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0x3685
movq 0x9a3d(%rip), %rcx      # 0x10dc0
movq %rax, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/pahihu[P]mixal/run.c
// Function: load_memory
static void load_memory(const char *path, Cell *store, unsigned size)
{
    FILE *fin;

    fin = fopen(path, "rb");
    if (NULL == fin)
        return;
    fread(store, sizeof(Cell), size, fin);
    fclose(fin);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
leaq 0x208d(%rip), %rsi      # 0x942c
callq 0x3250
testq %rax, %rax
je 0x73c8
movq %rax, %r14
movl %ebp, %edx
pushq $0x8
popq %rsi
movq %rbx, %rdi
movq %rax, %rcx
callq 0x30d0
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x30f0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pahihu[P]mixal/run.c
// Function: do_add
static void do_add(void)
{
    if (6 == F) {
        check_float();
        r[A] = float_add(r[A], safe_fetch(cell_to_address(M)));
        elapsed_time += 2;
    } else
        r[A] = add(r[A], get_V());
}

// Assembly:
pushq %rbx
cmpl $0x6, 0x9a16(%rip)      # 0x10dec
jne 0x740c
callq 0x7ef6
movq 0x997c(%rip), %rbx      # 0x10d60
movq 0x9a05(%rip), %rdi      # 0x10df0
callq 0x3e15
movl %eax, %edi
callq 0x6ce5
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3e6e
addq $0x2, 0x9926(%rip)      # 0x10d30
jmp 0x7423
movq 0x994d(%rip), %rbx      # 0x10d60
callq 0x7f0e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x38b0
movq %rax, 0x9936(%rip)      # 0x10d60
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/pahihu[P]mixal/run.c
// Function: do_sub
static void do_sub(void)
{
    if (6 == F) {
        check_float();
        r[A] = float_subtract(r[A], safe_fetch(cell_to_address(M)));
        elapsed_time += 2;
    } else
        r[A] = sub(r[A], get_V());
}

// Assembly:
pushq %rbx
cmpl $0x6, 0x99b8(%rip)      # 0x10dec
jne 0x746a
callq 0x7ef6
movq 0x991e(%rip), %rbx      # 0x10d60
movq 0x99a7(%rip), %rdi      # 0x10df0
callq 0x3e15
movl %eax, %edi
callq 0x6ce5
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3e81
addq $0x2, 0x98c8(%rip)      # 0x10d30
jmp 0x7481
movq 0x98ef(%rip), %rbx      # 0x10d60
callq 0x7f0e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3909
movq %rax, 0x98d8(%rip)      # 0x10d60
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/pahihu[P]mixal/run.c
// Function: do_mul
static void do_mul(void)
{
    if (6 == F) {
        check_float();
        r[A] = float_multiply(r[A], safe_fetch(cell_to_address(M)));
        /* NB. FMUL is 9u, MUL is 10 */
        elapsed_time -= 1;
    } else
        multiply(r[A], get_V(), &r[A], &r[X]);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x6, 0x9957(%rip)      # 0x10dec
jne 0x74d7
callq 0x7ef6
movq 0x98bd(%rip), %rbx      # 0x10d60
movq 0x9946(%rip), %rdi      # 0x10df0
callq 0x3e15
movl %eax, %edi
callq 0x6ce5
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3e94
movq %rax, 0x9898(%rip)      # 0x10d60
decq 0x9861(%rip)            # 0x10d30
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x9882(%rip), %rbx      # 0x10d60
leaq 0x987b(%rip), %r14      # 0x10d60
callq 0x7f0e
leaq 0x98a7(%rip), %rcx      # 0x10d98
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3915
// File: /workspace/github_c_makefile_star2_O2/pahihu[P]mixal/run.c
// Function: do_div
static void do_div(void)
{
    if (6 == F) {
        check_float();
        r[A] = float_divide(r[A], safe_fetch(cell_to_address(M)));
        /* NB. FDIV is 11u, DIV is 12u */
        elapsed_time -= 1;
    } else
        divide(r[A], r[X], get_V(), &r[A], &r[X]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x6, 0x98d7(%rip)      # 0x10dec
jne 0x755b
callq 0x7ef6
movq 0x983d(%rip), %rbx      # 0x10d60
movq 0x98c6(%rip), %rdi      # 0x10df0
callq 0x3e15
movl %eax, %edi
callq 0x6ce5
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3ea7
movq %rax, 0x9818(%rip)      # 0x10d60
decq 0x97e1(%rip)            # 0x10d30
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x97fe(%rip), %rbx      # 0x10d60
leaq 0x97f7(%rip), %r14      # 0x10d60
movq 0x9828(%rip), %r15      # 0x10d98
leaq 0x9821(%rip), %r12      # 0x10d98
callq 0x7f0e
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %r14, %rcx
movq %r12, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3a24
// File: /workspace/github_c_makefile_star2_O2/pahihu[P]mixal/run.c
// Function: do_move
static void do_move(void)
{
    Address from = cell_to_address(M);
    Address to = cell_to_address(r[1]);
    unsigned i, count = F;

    for (i = 0; i < count; i++) {
        safe_store(to + i, safe_fetch(from + i));
        elapsed_time += 2;
    }
    r[1] = address_to_cell(to + count);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x92cb(%rip), %rdi      # 0x10df0
callq 0x3e15
movl %eax, %ebx
movq 0x9235(%rip), %rdi      # 0x10d68
callq 0x3e15
movl %eax, %ebp
movl 0x92ab(%rip), %r14d     # 0x10dec
movl %eax, %r15d
movl %r14d, %r12d
subl $0x1, %r12d
jb 0x7b6e
movl %ebx, %edi
callq 0x6ce5
movl %r15d, %edi
movq %rax, %rsi
callq 0x7f90
addq $0x2, 0x91c9(%rip)      # 0x10d30
incl %r15d
incl %ebx
jmp 0x7b47
addl %ebp, %r14d
movl %r14d, %edi
callq 0x3e11
movq %rax, 0x91e8(%rip)      # 0x10d68
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pahihu[P]mixal/run.c
// Function: do_ldi
static void do_ldi(void) { 
    Cell cell = get_V();
    if (INDEX_MAX < magnitude(cell))
        error("Magnitude too large for index register: %10o", magnitude(cell));
    r[C & 7] = cell; 
}

// Assembly:
pushq %rbx
callq 0x7f0e
movq %rax, %rbx
movl %ebx, %esi
andl $0x3fffffff, %esi       # imm = 0x3FFFFFFF
cmpq %rsi, 0x9208(%rip)      # 0x10db8
jge 0x7bc0
leaq 0x26e9(%rip), %rdi      # 0xa2a2
xorl %eax, %eax
callq 0x5700
movl 0x9222(%rip), %eax      # 0x10de8
andl $0x7, %eax
leaq 0x9190(%rip), %rcx      # 0x10d60
movq %rbx, (%rcx,%rax,8)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/pahihu[P]mixal/run.c
// Function: do_ldin
static void do_ldin(void) {
    Cell cell = get_V();
    if (INDEX_MAX < magnitude(cell))
        error("Magnitude too large for index register: %10o", magnitude(cell));
    r[C & 7] = negative(cell);
}

// Assembly:
pushq %rbx
callq 0x7f0e
movq %rax, %rbx
movl %ebx, %esi
andl $0x3fffffff, %esi       # imm = 0x3FFFFFFF
cmpq %rsi, 0x91a6(%rip)      # 0x10db8
jge 0x7c22
leaq 0x2687(%rip), %rdi      # 0xa2a2
xorl %eax, %eax
callq 0x5700
xorq $0x40000000, %rbx       # imm = 0x40000000
movl 0x91b9(%rip), %eax      # 0x10de8
andl $0x7, %eax
leaq 0x9127(%rip), %rcx      # 0x10d60
movq %rbx, (%rcx,%rax,8)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/pahihu[P]mixal/run.c
// Function: do_addr_op
static void do_addr_op(void)
{
    Cell cell;
    unsigned reg = C & 7;

    switch (F) {
    case 0: cell = add(r[reg], M); break;
    case 1: cell = sub(r[reg], M); break;
    case 2: cell = M; break;
    case 3: cell = negative(M); break;
    case 4: check_master(); compare(M); return;
    default: error("Unknown extended opcode"); cell = zero;
    }
    if (reg - 1 < 6)        /* same as: 1 <= reg && reg <= 6 */
        if (INDEX_MAX < magnitude(cell))
            error("Magnitude too large for index register: %10o", 
              magnitude(cell));
    r[reg] = cell;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x900d(%rip), %r15d     # 0x10de8
andl $0x7, %r15d
movl 0x9007(%rip), %eax      # 0x10dec
movl %r15d, %r14d
cmpq $0x4, %rax
ja 0x7e60
leaq 0x1f2b(%rip), %rcx      # 0x9d20
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8f5b(%rip), %rax      # 0x10d60
movq (%rax,%r15,8), %rdi
movq 0x8fe0(%rip), %rsi      # 0x10df0
callq 0x38b0
jmp 0x7e5b
callq 0x7f78
movq 0x8fcd(%rip), %rdi      # 0x10df0
popq %rbx
popq %r14
popq %r15
jmp 0x8089
movq 0x8fbc(%rip), %rbx      # 0x10df0
jmp 0x7e70
movl $0x40000000, %ebx       # imm = 0x40000000
xorq 0x8fae(%rip), %rbx      # 0x10df0
jmp 0x7e70
leaq 0x8f15(%rip), %rax      # 0x10d60
movq (%rax,%r14,8), %rdi
movq 0x8f9a(%rip), %rsi      # 0x10df0
callq 0x3909
movq %rax, %rbx
jmp 0x7e70
leaq 0x23d0(%rip), %rdi      # 0xa237
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x5700
leal -0x1(%r15), %eax
cmpl $0x5, %eax
ja 0x7e98
movl %ebx, %esi
andl $0x3fffffff, %esi       # imm = 0x3FFFFFFF
cmpq %rsi, 0x8f30(%rip)      # 0x10db8
jge 0x7e98
leaq 0x2411(%rip), %rdi      # 0xa2a2
xorl %eax, %eax
callq 0x5700
leaq 0x8ec1(%rip), %rax      # 0x10d60
movq %rbx, (%rax,%r14,8)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pahihu[P]mixal/run.c
// Function: do_compare
static void do_compare(void)
{
    Cell cell = safe_fetch(cell_to_address(M));

    if (6 == F) {
        check_float();
        comparison_indicator = float_compare(r[A], cell);
        elapsed_time += 2;
    } else
        compare(cell);
}

// Assembly:
pushq %rbx
movq 0x8f3f(%rip), %rdi      # 0x10df0
callq 0x3e15
movl %eax, %edi
callq 0x6ce5
movq %rax, %rbx
cmpl $0x6, 0x8f25(%rip)      # 0x10dec
jne 0x7eed
callq 0x7ef6
movq 0x8e8b(%rip), %rdi      # 0x10d60
movq %rbx, %rsi
callq 0x3ee0
movl %eax, 0x8e61(%rip)      # 0x10d44
addq $0x2, 0x8e45(%rip)      # 0x10d30
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x8089
// File: /workspace/github_c_makefile_star2_O2/pahihu[P]mixal/run.c
// Function: flip_char
static Cell flip_char(Cell cell)
{
    Cell ret = cell;
    Byte mix_char;

    mix_char = get_byte(5, ret);
    if ((9 < mix_char) && (mix_char < 20)) {
        mix_char = mix_char + 20;
        ret = set_byte(mix_char, 5, ret);
    }
    return ret;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x5
popq %rdi
movq %rbx, %rsi
callq 0x357c
leal -0xa(%rax), %ecx
cmpl $0x9, %ecx
ja 0x7f5b
addl $0x14, %eax
pushq $0x5
popq %rsi
movl %eax, %edi
movq %rbx, %rdx
popq %rbx
jmp 0x363f
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/pahihu[P]mixal/run.c
// Function: branch
static void branch(unsigned condition, int sign, Cell cell)
{
    switch (condition) {
    case  0: jump(); break;
    case  1: pc = cell_to_address(M); break;
    case  2: if (overflow)  jump(); overflow = false; break;
    case  3: if (!overflow) jump(); overflow = false; break;
    case  4: if (sign <  0) jump(); break;
    case  5: if (sign == 0) jump(); break;
    case  6: if (sign  > 0) jump(); break;
    case  7: if (sign >= 0) jump(); break;
    case  8: if (sign != 0) jump(); break;
    case  9: if (sign <= 0) jump(); break;
    case 10: check_binary(); if (0 == (magnitude(cell) & 2)) jump(); break;
    case 11: check_binary(); if (1 == (magnitude(cell) & 2)) jump(); break;
    default: error("Bad branch condition");
    }
}

// Assembly:
pushq %rbx
cmpl $0xb, %edi
ja 0x807a
movl %edi, %eax
leaq 0x1d38(%rip), %rcx      # 0x9d34
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8de4(%rip), %rdi      # 0x10df0
callq 0x3e15
movl %eax, 0x8d99(%rip)      # 0x10db0
jmp 0x805d
popq %rbx
jmp 0x7f60
testl %esi, %esi
jns 0x805d
jmp 0x8053
testl %esi, %esi
jg 0x805d
jmp 0x8053
leaq 0x7b0e(%rip), %rbx      # 0xfb40
cmpl $0x0, (%rbx)
je 0x803c
callq 0x7fc2
andl $0x0, (%rbx)
jmp 0x805d
leaq 0x7af8(%rip), %rbx      # 0xfb40
cmpl $0x0, (%rbx)
jne 0x803c
jmp 0x8037
testl %esi, %esi
js 0x805d
popq %rbx
jmp 0x7fc2
testl %esi, %esi
je 0x8053
popq %rbx
retq
testl %esi, %esi
jg 0x8053
jmp 0x805d
movq %rdx, %rbx
callq 0x7f60
testb $0x2, %bl
je 0x8053
jmp 0x805d
testl %esi, %esi
jne 0x8053
jmp 0x805d
leaq 0x224e(%rip), %rdi      # 0xa2cf
xorl %eax, %eax
popq %rbx
jmp 0x5700
// File: /workspace/github_c_makefile_star2_O2/pahihu[P]mixal/run.c
// Function: compare
static void compare(Cell cell)
{
    Flag saved = overflow;

    Cell difference = sub(field(F, r[C & 7]), field(F, cell));
    comparison_indicator = sign_of_difference(difference);
    overflow = saved;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7aa6(%rip), %r15      # 0xfb40
movl (%r15), %ebp
movl 0x8d49(%rip), %edi      # 0x10dec
movl 0x8d3f(%rip), %eax      # 0x10de8
andl $0x7, %eax
leaq 0x8cad(%rip), %rcx      # 0x10d60
movq (%rcx,%rax,8), %rsi
callq 0x35b3
movq %rax, %r14
movl 0x8d27(%rip), %edi      # 0x10dec
movq %rbx, %rsi
callq 0x35b3
movq %r14, %rdi
movq %rax, %rsi
callq 0x3909
xorl %ecx, %ecx
btl $0x1e, %eax
movl $0x0, %edx
sbbl %edx, %edx
orl $0x1, %edx
testl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
cmovel %ecx, %edx
movl %edx, 0x8c4e(%rip)      # 0x10d44
movl %ebp, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pahihu[P]mixal/symbol.c
// Function: string_to_symbol
Symbol string_to_symbol(const char *name)
{
    Symbol *bucket = symbol_table + hash(name);
    Symbol p = *bucket;
    for (; p; p = p->next)
	    if (stricmp(name, p->name) == 0)
	        return p;
    {                   /* Symbol doesn't exist yet. */
	    Symbol result = allot(sizeof(struct Symbol));
	    strcpy(result->name = allot(strlen(name) + 1), name);
	    result->defined = false;
	    result->references = NULL;
	    result->next = *bucket;
	    result->cell = zero;
	    *bucket = result;
	    return result;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
movq %rdi, %r14
movsbq (%r14), %r15
testq %r15, %r15
je 0x8131
imull $0x1f, %ebp, %ebp
callq 0x3030
movq (%rax), %rax
addl (%rax,%r15,4), %ebp
incq %r14
jmp 0x8114
pushq $0x11
popq %rcx
movl %ebp, %eax
xorl %edx, %edx
divl %ecx
leaq 0x8d9f(%rip), %rax      # 0x10ee0
leaq (%rax,%rdx,8), %r15
movq %r15, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x8188
movq 0x8(%r14), %r12
callq 0x32c0
movq (%rax), %rax
xorl %ecx, %ecx
movsbq (%rbx,%rcx), %r8
movsbq (%r12,%rcx), %rdi
movl (%rax,%r8,4), %edx
movl (%rax,%rdi,4), %esi
testq %r8, %r8
je 0x8182
testb %dil, %dil
je 0x8182
cmpl %esi, %edx
jne 0x8148
incq %rcx
jmp 0x815e
cmpl %esi, %edx
jne 0x8148
jmp 0x81cb
pushq $0x28
popq %rdi
callq 0x81d7
movq %rax, %r14
movq %rbx, %rdi
callq 0x3100
leaq 0x1(%rax), %rdi
callq 0x81d7
movq %rax, 0x8(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3090
andl $0x0, 0x10(%r14)
andq $0x0, 0x20(%r14)
movq (%r15), %rax
movq %rax, (%r14)
andq $0x0, 0x18(%r14)
movq %r14, (%r15)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pahihu[P]mixal/symbol.c
// Function: allot
static void *allot(size_t size)
{
    void *result = malloc(size);
    if (!result)
	    fatal_error("Out of heap space");
    return result;
}

// Assembly:
pushq %rbx
callq 0x31f0
movq %rax, %rbx
testq %rax, %rax
jne 0x81f3
leaq 0x2307(%rip), %rdi      # 0xa4f3
xorl %eax, %eax
callq 0x560c
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/pahihu[P]mixal/symbol.c
// Function: forward_reference
void forward_reference(Symbol symbol, Address address)
{
    assert(!symbol->defined);
    {
	    AddressList refs = allot(sizeof(struct AddressList));
	    refs->address = address;
	    refs->next = symbol->references;
	    symbol->references = refs;
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x0, 0x10(%rdi)
jne 0x8250
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x81d7
movl %ebp, 0x8(%rax)
movq 0x20(%rbx), %rcx
movq %rcx, (%rax)
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x222c(%rip), %rdi      # 0xa483
leaq 0x2202(%rip), %rsi      # 0xa460
leaq 0x222f(%rip), %rcx      # 0xa494
pushq $0x78
popq %rdx
callq 0x3130
// File: /workspace/github_c_makefile_star2_O2/pahihu[P]mixal/symbol.c
// Function: define_symbol
void define_symbol(Symbol symbol, Cell cell)
{
    {   /* handle local symbols */
	    const char *name = symbol->name;
	    if (isdigit(name[0]) && strlen(name) == 2) {
            char c = toupper(name[1]);
            if (c == 'F' || c == 'B') {
                error("Definition of local ref: %s", name);
                return;
            } else if (c == 'H') {
                char new_name[3];
                Symbol nB, nF;
                strcpy(new_name, name);
                new_name[1] = 'B'; nB = string_to_symbol(new_name);
                nB->defined = true, nB->cell = cell;
                new_name[1] = 'F'; nF = string_to_symbol(new_name);
                resolve_references(nF, cell);
                nF->defined = false, nF->references = NULL;
                return;
            } else
                ;       /* not a local; fall through */
        }
    }
    if (symbol->defined)
	    warn("'%s' multiply-defined", symbol->name);
    else
	    resolve_references(symbol, cell);
    symbol->defined = true, symbol->cell = cell;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
callq 0x32d0
movq (%rax), %rax
movsbq (%r15), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x8337
movq %r15, %rdi
callq 0x3100
cmpq $0x2, %rax
jne 0x8337
callq 0x3030
movq (%rax), %rax
movsbq 0x1(%r15), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %ecx
andl $0xfb, %ecx
cmpl $0x42, %ecx
jne 0x82e0
leaq 0x21ef(%rip), %rdi      # 0xa4bc
movq %r15, %rsi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x5700
movzbl %al, %eax
cmpl $0x48, %eax
jne 0x8337
leaq 0xd(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x3090
movb $0x42, 0x1(%r14)
movq %r14, %rdi
callq 0x8104
movl $0x1, 0x10(%rax)
movq %rbx, 0x18(%rax)
movb $0x46, 0x1(%r14)
movq %r14, %rdi
callq 0x8104
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8372
andl $0x0, 0x10(%r14)
andq $0x0, 0x20(%r14)
jmp 0x8368
cmpl $0x0, 0x10(%r14)
je 0x8351
leaq 0x2193(%rip), %rdi      # 0xa4d8
movq %r15, %rsi
xorl %eax, %eax
callq 0x57c3
jmp 0x835c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8372
movl $0x1, 0x10(%r14)
movq %rbx, 0x18(%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pahihu[P]mixal/symbol.c
// Function: resolve_references
static void resolve_references(Symbol symbol, Cell definition)
{
    AddressList refs, rest;
    assert(!symbol->defined);
    for (refs = symbol->references; refs; refs = rest) {
	    asm_store_field(refs->address, 0, 2, definition);
	    rest = refs->next;
	    free(refs);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x10(%rdi)
jne 0x83b9
movq %rsi, %rbx
movq 0x20(%rdi), %r14
pushq $0x2
popq %rbp
testq %r14, %r14
je 0x83ae
movl 0x8(%r14), %edi
xorl %esi, %esi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x342b
movq (%r14), %r15
movq %r14, %rdi
callq 0x3040
movq %r15, %r14
jmp 0x8389
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20c3(%rip), %rdi      # 0xa483
leaq 0x2099(%rip), %rsi      # 0xa460
leaq 0x2137(%rip), %rcx      # 0xa505
movl $0x87, %edx
callq 0x3130
// File: /workspace/github_c_makefile_star2_O2/CBaquero[P]random/Random.cc
// Function: RandomDUnif_RedisCommand(RedisModuleCtx*, RedisModuleString**, int)
int RandomDUnif_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
  if (argc != 3) return RedisModule_WrongArity(ctx);
  long long start, end;
  if (
      (RedisModule_StringToLongLong(argv[1],&start) != REDISMODULE_OK) ||
      (RedisModule_StringToLongLong(argv[2],&end) != REDISMODULE_OK) ||
      (start > end) 
      ) 
    return RedisModule_ReplyWithError(ctx,"ERR invalid range");

  std::uniform_int_distribution<long long> rdunif(start,end);
  RedisModule_ReplyWithLongLong(ctx,rdunif(gen));
  return REDISMODULE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0x3, %edx
jne 0x53c4
movq %rsi, %r14
movq 0x5ba5(%rip), %r15      # 0xaf20
movq 0x8(%rsi), %rdi
leaq -0x28(%rbp), %rsi
callq *(%r15)
testl %eax, %eax
jne 0x53a6
movq 0x10(%r14), %rdi
leaq -0x20(%rbp), %rsi
callq *(%r15)
testl %eax, %eax
jne 0x53a6
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jle 0x53da
movq 0x59c3(%rip), %rax      # 0xad70
leaq 0x2cbc(%rip), %rsi      # 0x8070
movq %rbx, %rdi
callq *(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x5b75(%rip), %rax      # 0xaf40
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *(%rax)
leaq -0x38(%rbp), %rdi
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
movq 0x5b84(%rip), %rax      # 0xaf70
movq (%rax), %r14
movq 0x5ba2(%rip), %rsi      # 0xaf98
callq 0x5170
movq %rbx, %rdi
movq %rax, %rsi
callq *%r14
xorl %eax, %eax
jmp 0x53b9
// File: /workspace/github_c_makefile_star2_O2/CBaquero[P]random/Random.cc
// Function: RandomUnif_RedisCommand(RedisModuleCtx*, RedisModuleString**, int)
int RandomUnif_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
  if (argc != 3) return RedisModule_WrongArity(ctx);
  double start, end;
  if (
      (RedisModule_StringToDouble(argv[1],&start) != REDISMODULE_OK) ||
      (RedisModule_StringToDouble(argv[2],&end) != REDISMODULE_OK) ||
      (start > end) 
      ) 
    return RedisModule_ReplyWithError(ctx,"ERR invalid range");

  std::uniform_real_distribution<double> runif(start,end);
  RedisModule_ReplyWithDouble(ctx,runif(gen));
  return REDISMODULE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0x3, %edx
jne 0x5473
movq %rsi, %r14
movq 0x5ab9(%rip), %r15      # 0xaee0
movq 0x8(%rsi), %rdi
leaq -0x28(%rbp), %rsi
callq *(%r15)
testl %eax, %eax
jne 0x5455
movq 0x10(%r14), %rdi
leaq -0x20(%rbp), %rsi
callq *(%r15)
testl %eax, %eax
jne 0x5455
movsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x5489
movq 0x5914(%rip), %rax      # 0xad70
leaq 0x2c0d(%rip), %rsi      # 0x8070
movq %rbx, %rdi
callq *(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x5ac6(%rip), %rax      # 0xaf40
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *(%rax)
leaq -0x38(%rbp), %rdi
movsd %xmm0, (%rdi)
movsd %xmm1, 0x8(%rdi)
movq 0x5773(%rip), %rax      # 0xac10
movq (%rax), %r14
movq 0x5af1(%rip), %rsi      # 0xaf98
callq 0x5210
movq %rbx, %rdi
callq *%r14
xorl %eax, %eax
jmp 0x5468
// File: /workspace/github_c_makefile_star2_O2/CBaquero[P]random/Random.cc
// Function: RandomNorm_RedisCommand(RedisModuleCtx*, RedisModuleString**, int)
int RandomNorm_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
  double mean=0.0, sd=1.0;
  if (argc > 3) return RedisModule_WrongArity(ctx);
  if (argc >= 2) /* Get mean */
  {
    if (RedisModule_StringToDouble(argv[1],&mean) != REDISMODULE_OK)
      return RedisModule_ReplyWithError(ctx,"ERR invalid mean");
  }
  if (argc == 3) /* get stddev */
  {
    if (RedisModule_StringToDouble(argv[2],&sd) != REDISMODULE_OK)
      return RedisModule_ReplyWithError(ctx,"ERR invalid standard deviation");
  }

  std::normal_distribution<double> rnorm(mean,sd);
  RedisModule_ReplyWithDouble(ctx, rnorm(gen));
  return REDISMODULE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
andq $0x0, -0x30(%rbp)
movq %rdi, %rbx
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x28(%rbp)
cmpl $0x4, %edx
jl 0x54f8
movq 0x5a59(%rip), %rax      # 0xaf40
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *(%rax)
movl %edx, %r15d
movsd 0x2afd(%rip), %xmm1     # 0x8000
cmpl $0x2, %edx
jl 0x556a
movq %rsi, %r14
movq 0x59ce(%rip), %r12      # 0xaee0
movq 0x8(%rsi), %rdi
leaq -0x30(%rbp), %rsi
callq *(%r12)
testl %eax, %eax
je 0x5537
movq 0x5847(%rip), %rax      # 0xad70
leaq 0x2b52(%rip), %rsi      # 0x8082
movq %rbx, %rdi
callq *(%rax)
jmp 0x55a3
cmpl $0x3, %r15d
movsd 0x2abd(%rip), %xmm1     # 0x8000
jne 0x556a
movq 0x10(%r14), %rdi
leaq -0x28(%rbp), %rsi
callq *(%r12)
testl %eax, %eax
je 0x5565
movq 0x5814(%rip), %rax      # 0xad70
leaq 0x2b30(%rip), %rsi      # 0x8093
jmp 0x5530
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
leaq -0x50(%rbp), %rdi
movsd %xmm0, (%rdi)
movsd %xmm1, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movq 0x5684(%rip), %rax      # 0xac10
movq (%rax), %r14
movq 0x5a02(%rip), %rsi      # 0xaf98
callq 0x5130
movq %rbx, %rdi
callq *%r14
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/CBaquero[P]random/Random.cc
// Function: RandomExp_RedisCommand(RedisModuleCtx*, RedisModuleString**, int)
int RandomExp_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
  double lambda;
  if (argc > 2) return RedisModule_WrongArity(ctx);
  if (argc == 2)
  {
    if (RedisModule_StringToDouble(argv[1],&lambda) != REDISMODULE_OK)
      return RedisModule_ReplyWithError(ctx,"ERR invalid lambda");
  }
  else // If no parameter, use default lambda of 1
    lambda=1.0;
  std::exponential_distribution<double> rexp(lambda);
  RedisModule_ReplyWithDouble(ctx, rexp(gen));
  return REDISMODULE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x3, %edx
jl 0x59a4
movq 0x55a9(%rip), %rax      # 0xaf40
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmpq *(%rax)
cmpl $0x2, %edx
jne 0x59d3
movq 0x5530(%rip), %rax      # 0xaee0
movq 0x8(%rsi), %rdi
leaq -0x18(%rbp), %rsi
callq *(%rax)
testl %eax, %eax
je 0x59eb
movq 0x53ab(%rip), %rax      # 0xad70
leaq 0x2762(%rip), %rsi      # 0x812e
movq %rbx, %rdi
callq *(%rax)
jmp 0x5a16
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x18(%rbp)
movsd 0x2617(%rip), %xmm0     # 0x8000
jmp 0x59f0
movsd -0x18(%rbp), %xmm0
leaq -0x20(%rbp), %rdi
movsd %xmm0, (%rdi)
movq 0x5211(%rip), %rax      # 0xac10
movq (%rax), %r14
movq 0x558f(%rip), %rsi      # 0xaf98
callq 0x5230
movq %rbx, %rdi
callq *%r14
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/giometti[P]mastering_UNIX_programming/chapter_08/environ.c
// Function: main
int main(int argc, char *argv[])
{
	int n;

	for (n = 0; environ[n]; n++)
		printf("environ[%d]=\"%s\"\n", n, environ[n]);

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x2ea0(%rip), %r15      # 0x3fe8
leaq 0xeb5(%rip), %rbx       # 0x2004
xorl %r14d, %r14d
movq (%r15), %rax
movq (%rax,%r14,8), %rdx
testq %rdx, %rdx
je 0x1170
movq %rbx, %rdi
movl %r14d, %esi
xorl %eax, %eax
callq 0x1030
incq %r14
jmp 0x1152
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/aes128n12t8silcv2/aesni/encrypt.c
// Function: load_partial_block
void load_partial_block(block* dst, const unsigned char* m, int len, unsigned choice)
{
    unsigned char temp[16];
    if(choice == ZERO_APPEND){
        memcpy(temp, m, len);
        memset(temp+len, 0, 16-len);
        *dst = LOAD(temp);
    }
    else if(choice == ZERO_PREPEND){
        memcpy(temp+16-len, m, len);
        memset(temp, 0, 16-len);
        *dst = LOAD(temp);
    }
    else if(choice == PARAM_ZP){
        memcpy(temp+16-len, m, len);
        memset(temp, 0, 16-len-1);
        temp[16-len-1] = PARAM;
        *dst = LOAD(temp);
    }
    else{
        // do nothing
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rdi, %rbx
cmpl $0x3, %ecx
je 0x1372
cmpl $0x1, %ecx
je 0x1349
testl %ecx, %ecx
jne 0x13ae
movslq %ebp, %r14
movq %rsp, %rdi
movq %r14, %rdx
callq 0x1090
leaq (%rsp,%r14), %rdi
pushq $0x10
popq %rax
subl %ebp, %eax
movslq %eax, %rdx
jmp 0x1369
movslq %ebp, %rdx
movq %rsp, %r14
movq %r14, %rdi
subq %rdx, %rdi
addq $0x10, %rdi
callq 0x1090
pushq $0x10
popq %rax
subl %ebp, %eax
movslq %eax, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x1030
jmp 0x13a5
movslq %ebp, %r14
movq %rsp, %r15
movq %r15, %rdi
subq %r14, %rdi
addq $0x10, %rdi
movq %r14, %rdx
callq 0x1090
pushq $0xf
popq %rax
subl %r14d, %eax
movslq %eax, %r14
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1030
movb $-0x40, (%rsp,%r14)
vmovaps (%rsp), %xmm0
vmovaps %xmm0, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/aes128n12t8silcv2/aesni/encrypt.c
// Function: xor_length
void xor_length(block* st, unsigned long long len)
{
    unsigned char temp[16] = { 0 };
    int i;
    for(i = 0;i < 8;i++){
        temp[15-i] = len & 0xff;
        len >>= 8;
    }
    (*st) = XOR((*st), LOAD(temp));
}

// Assembly:
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, -0x18(%rsp)
movabsq $0x8, %rcx
movq %rcx, %rax
subq $0x1, %rax
jb 0x13e4
movb %sil, -0x11(%rsp,%rcx)
shrq $0x8, %rsi
movq %rax, %rcx
jmp 0x13d0
vmovaps -0x18(%rsp), %xmm0
vxorps (%rdi), %xmm0, %xmm0
vmovaps %xmm0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/glk[P]critbit/critbit.c
// Function: critbit_get_impl
static __inline struct critbit_key *
critbit_get_impl(struct critbit_tree *t, const void *key, size_t keylen,
    critbit_keycmp_t *keycmp, critbit_keybuf_t *keybuf)
{
	const uint8_t *ubytes = key;
	struct critbit_node *node;
	struct critbit_ref *ref;
	uint8_t c;

	ref = t->ct_root;
	if (ref == NULL)
		return (0);

	while (critbit_ref_is_internal(ref)) {
		node = critbit_ref_get_node(ref);

		c = 0;
		if (node->byte < keylen)
			c = ubytes[node->byte];

		const int direction = (1 + (node->otherbits | c)) >> 8;
		ref = node->child[direction];
	}

	if (keycmp(keybuf(critbit_ref_get_key(ref)), ubytes, keylen) == 0)
		return (critbit_ref_get_key(ref));

	return (NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rbx
testq %rbx, %rbx
je 0xd244
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
testb $0x1, %bl
je 0xd226
movl 0xf(%rbx), %eax
cmpq %r15, %rax
jae 0xd212
movzbl (%r12,%rax), %eax
jmp 0xd214
xorl %eax, %eax
movzbl 0x13(%rbx), %ecx
orl %ecx, %eax
incl %eax
shrl $0x8, %eax
movq -0x1(%rbx,%rax,8), %rbx
jmp 0xd1fe
movq %rbx, %rdi
callq *%r8
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *%r14
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmoveq %rbx, %rax
jmp 0xd246
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/glk[P]critbit/critbit.c
// Function: critbit_remove_impl
static __inline struct critbit_key *
critbit_remove_impl(struct critbit_tree *t, const void *key, size_t keylen,
    critbit_keycmp_t *keycmp, critbit_keybuf_t *keybuf)
{
	const uint8_t *ubytes = key;
	struct critbit_ref *p = t->ct_root;
	struct critbit_node *q = NULL;
	struct critbit_ref **wherep = &t->ct_root;
	struct critbit_ref **whereq = NULL;
	int direction = 0;

	if (p == NULL)
		return (NULL);

	while (critbit_ref_is_internal(p)) {
		whereq = wherep;
		q = critbit_ref_get_node(p);
		uint8_t c = 0;
		if (q->byte < keylen)
			c = ubytes[q->byte];
		direction = (1 + (q->otherbits | c)) >> 8;
		wherep = q->child + direction;
		p = *wherep;
	}

	if (keycmp(keybuf(critbit_ref_get_key(p)), ubytes, keylen) != 0)
		return (NULL);

	/* Remove p */

	if (whereq == NULL) {
		t->ct_root = NULL;
		return (critbit_ref_get_key(p));
	}

	*whereq = q->child[1 - direction];
	critbit_node_free(t, q);

	return (critbit_ref_get_key(p));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %rbx
xorl %r15d, %r15d
testq %rbx, %rbx
je 0xd44a
movq %rdx, %r12
movq %rsi, %r13
movq %rcx, 0x10(%rsp)
xorl %ebp, %ebp
movq %rdi, 0x8(%rsp)
movq %rdi, %rcx
xorl %r14d, %r14d
testb $0x1, %bl
je 0xd433
movq %rcx, %rax
movl 0xf(%rbx), %edx
xorl %ecx, %ecx
cmpq %r12, %rdx
jae 0xd40a
movzbl (%r13,%rdx), %ecx
leaq -0x1(%rbx), %rbp
movzbl 0x13(%rbx), %r15d
orl %ecx, %r15d
incl %r15d
shrl $0x8, %r15d
leal (,%r15,8), %edx
leaq (%rdx,%rbp), %rcx
movq -0x1(%rbx,%rdx), %rbx
movq %rax, %r14
jmp 0xd3f2
movq %rbx, %rdi
callq *%r8
movq %rax, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq *0x10(%rsp)
testl %eax, %eax
je 0xd45e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %r14, %r14
je 0xd47e
pushq $0x1
popq %rax
subl %r15d, %eax
movq (%rbp,%rax,8), %rax
movq %rax, (%r14)
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq *0x18(%rdi)
jmp 0xd44c
movq 0x8(%rsp), %rax
andq $0x0, (%rax)
jmp 0xd44c
// File: /workspace/github_c_makefile_star2_O2/glk[P]critbit/critbit-test.c
// Function: benchmark_result
static void
benchmark_result(const char *name, intmax_t n, struct timeval *tstart, struct timeval *tend)
{
        double t;

        t = tend->tv_sec - tstart->tv_sec;
        t += (double)(tend->tv_usec - tstart->tv_usec) / (double)1000000;
        printf("%16s: %jd iterations in %lf seconds; %lf iterations/s\n",
            name, n, t, (double)n/t);
}

// Assembly:
movq %rsi, %rax
movq (%rcx), %rsi
movq 0x8(%rcx), %rcx
subq (%rdx), %rsi
cvtsi2sd %rsi, %xmm1
subq 0x8(%rdx), %rcx
cvtsi2sd %rcx, %xmm0
divsd 0xb4e(%rip), %xmm0      # 0xf020
movq %rdi, %rsi
addsd %xmm1, %xmm0
cvtsi2sd %rax, %xmm1
divsd %xmm0, %xmm1
leaq 0x7493(%rip), %rdi      # 0x1597c
movq %rax, %rdx
movb $0x2, %al
jmp 0xd060
// File: /workspace/github_c_makefile_star2_O2/derhass[P]glx_hook/glx_hook.c
// Function: dlsym
extern void *
dlsym(void *handle, const char *name)
{
	void *interceptor;
	void *ptr;
	/* special case: we cannot use GH_GET_PTR as it relies on
	 * GH_dlsym() which we have to query using GH_dlsym_internal */
	pthread_mutex_lock(&GH_fptr_mutex);
	GH_dlsym_internal_dlsym();
	pthread_mutex_unlock(&GH_fptr_mutex);
	interceptor=GH_get_interceptor(name, GH_dlsym_next, "dlsym");
	ptr=(interceptor)?interceptor:GH_dlsym(handle,name);
	GH_verbose(GH_MSG_DEBUG_INTERCEPTION,"dlsym(%p, %s) = %p%s\n",handle,name,ptr,
		interceptor?" [intercepted]":"");
	return ptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2ea7(%rip), %rdi      # 0x40c8
callq 0x1120
cmpq $0x0, 0x2ec2(%rip)      # 0x40f0
je 0x126a
leaq 0x2e91(%rip), %rdi      # 0x40c8
callq 0x10c0
leaq 0x402(%rip), %rsi       # 0x1645
leaq 0xdd2(%rip), %rdx       # 0x201c
movq %rbx, %rdi
callq 0x13e9
testq %rax, %rax
je 0x1339
movq %rax, %r15
leaq 0xdd3(%rip), %r9        # 0x2038
jmp 0x1352
leaq 0xfba(%rip), %rsi       # 0x222b
pushq $0x4
popq %rdi
xorl %eax, %eax
callq 0x1677
leaq 0xd9a(%rip), %rsi       # 0x201c
leaq 0xfb9(%rip), %rdx       # 0x2242
pushq $-0x1
popq %rdi
callq 0x1110
movq %rax, 0x2e58(%rip)      # 0x40f0
movq 0x2e51(%rip), %r12      # 0x40f0
cmpq $0x0, 0x2e49(%rip)      # 0x40f0
je 0x137b
movq 0x2e3c(%rip), %rcx      # 0x40f0
leaq 0xe71(%rip), %rsi       # 0x212c
leaq 0xd5a(%rip), %r15       # 0x201c
movq 0x2cff(%rip), %r8       # 0x3fc8
pushq $0x5
popq %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1677
movq %r15, %rdi
callq 0x1645
cmpq 0x2e0b(%rip), %rax      # 0x40f0
je 0x139c
movq %rax, %r15
testq %rax, %rax
je 0x1384
leaq 0xe4f(%rip), %rdi       # 0x214d
pushq $0x1
popq %rsi
callq 0x1f1e
movq 0x2de3(%rip), %rcx      # 0x40f0
testl %eax, %eax
je 0x13cc
leaq 0xe4c(%rip), %rsi       # 0x2168
leaq 0xcf9(%rip), %rdx       # 0x201c
pushq $0x5
popq %rdi
movq %r15, %r8
xorl %eax, %eax
callq 0x1677
movq %r15, 0x2db9(%rip)      # 0x40f0
jmp 0x139c
movq 0x2db0(%rip), %rax      # 0x40f0
movq %r14, %rdi
movq %rbx, %rsi
callq *%rax
movq %rax, %r15
leaq 0x107c(%rip), %r9       # 0x23ce
leaq 0xcc9(%rip), %rsi       # 0x2022
pushq $0x5
popq %rdi
movq %r14, %rdx
movq %rbx, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x1677
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xe87(%rip), %rsi       # 0x2209
jmp 0x138b
leaq 0xe44(%rip), %rsi       # 0x21cf
leaq 0xc8a(%rip), %rdx       # 0x201c
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x1677
testq %r12, %r12
je 0x1230
cmpq $0x0, 0x2d73(%rip)      # 0x4120
jne 0x1230
leaq 0xd6b(%rip), %rsi       # 0x2125
pushq $-0x1
popq %rdi
callq *%r12
movq %rax, 0x2d59(%rip)      # 0x4120
jmp 0x1230
leaq 0xdbc(%rip), %rsi       # 0x218f
leaq 0xc42(%rip), %rdx       # 0x201c
pushq $0x2
popq %rdi
movq %r15, %r8
xorl %eax, %eax
callq 0x1677
jmp 0x139c
// File: /workspace/github_c_makefile_star2_O2/derhass[P]glx_hook/glx_hook.c
// Function: glXSwapIntervalEXT
extern void glXSwapIntervalEXT(Display *dpy, GLXDrawable drawable,
				int interval)
{
	interval=GH_swap_interval(interval);
	if (interval == GH_SWAP_DONT_SET) {
		/* ignore the call */
		return;
	}
	GH_GET_PTR_GL(glXSwapIntervalEXT);
	GH_glXSwapIntervalEXT(dpy, drawable, interval);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %edi
callq 0x1acf
movl %eax, %ebp
negl %eax
jno 0x1a85
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x263c(%rip), %rdi      # 0x40c8
callq 0x1120
cmpq $0x0, 0x266f(%rip)      # 0x4108
jne 0x1aae
leaq 0x60b(%rip), %rdi       # 0x20ad
callq 0x1d65
movq %rax, 0x265a(%rip)      # 0x4108
leaq 0x2613(%rip), %rdi      # 0x40c8
callq 0x10c0
movq 0x2647(%rip), %rax      # 0x4108
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/derhass[P]glx_hook/glx_hook.c
// Function: GH_dlsym_gl
static void *GH_dlsym_gl(const char *name)
{
	static void *libgl_handle=NULL;
	static int try_load_libgl=1;

	void *ptr=GH_dlsym(RTLD_NEXT, name);
	if (!ptr) {
		if (try_load_libgl && !libgl_handle) {
			const char *libname=get_envs("GH_LIBGL_FILE", "libGL.so");
			if (libname[0]) {
				GH_verbose(GH_MSG_DEBUG, "trying to load libGL manually: '%s'\n", libname);
				libgl_handle=dlopen(libname, RTLD_GLOBAL | RTLD_LAZY);
				if (!libgl_handle) {
					GH_verbose(GH_MSG_WARNING, "failed to load '%s' manually\n", libname);
					/* give up on loading libGL */
					try_load_libgl=0;
				}
			} else {
				try_load_libgl=0;
			}
		}
		if (libgl_handle) {
			GH_verbose(GH_MSG_DEBUG, "trying to find '%s' in manually loaded libGL\n", name);
			ptr=GH_dlsym(libgl_handle, name);
		}
	}
	return ptr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x237d(%rip), %rax      # 0x40f0
pushq $-0x1
popq %rdi
movq %rbx, %rsi
callq *%rax
testq %rax, %rax
je 0x1d88
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x23d1(%rip), %rax      # 0x4160
testq %rax, %rax
setne %cl
orb 0x23cd(%rip), %cl       # 0x4168
testb $0x1, %cl
jne 0x1e13
leaq 0x5ec(%rip), %rdi       # 0x2393
callq 0x1030
testq %rax, %rax
leaq 0x5eb(%rip), %r14       # 0x23a1
cmovneq %rax, %r14
cmpb $0x0, (%r14)
je 0x1e0a
leaq 0x5e3(%rip), %rsi       # 0x23aa
pushq $0x4
popq %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1677
movq %r14, %rdi
movl $0x101, %esi            # imm = 0x101
callq 0x10a0
movq %rax, 0x2378(%rip)      # 0x4160
testq %rax, %rax
jne 0x1e18
leaq 0x5db(%rip), %rsi       # 0x23cf
pushq $0x2
popq %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1677
movq 0x2358(%rip), %rax      # 0x4160
jmp 0x1e0c
xorl %eax, %eax
movb $0x1, 0x2355(%rip)      # 0x4168
testq %rax, %rax
je 0x1e46
leaq 0x5ce(%rip), %rsi       # 0x23ed
pushq $0x4
popq %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1677
movq 0x22bd(%rip), %rax      # 0x40f0
movq 0x2326(%rip), %rdi      # 0x4160
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
xorl %eax, %eax
jmp 0x1d80
// File: /workspace/github_c_makefile_star2_O2/derhass[P]glx_hook/glx_hook.c
// Function: glXSwapIntervalSGI
extern int glXSwapIntervalSGI(int interval)
{
	interval=GH_swap_interval(interval);
	if (interval == GH_SWAP_DONT_SET) {
		/* ignore the call */
		return 0; /* success */
	}
	GH_GET_PTR_GL(glXSwapIntervalSGI);
	return GH_glXSwapIntervalSGI(interval);
}

// Assembly:
pushq %rbx
callq 0x1acf
movl %eax, %ebx
negl %eax
jno 0x1e5d
xorl %eax, %eax
popq %rbx
retq
leaq 0x2264(%rip), %rdi      # 0x40c8
callq 0x1120
cmpq $0x0, 0x229f(%rip)      # 0x4110
jne 0x1e86
leaq 0x246(%rip), %rdi       # 0x20c0
callq 0x1d65
movq %rax, 0x228a(%rip)      # 0x4110
leaq 0x223b(%rip), %rdi      # 0x40c8
callq 0x10c0
movq 0x2277(%rip), %rax      # 0x4110
movl %ebx, %edi
popq %rbx
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/derhass[P]glx_hook/glx_hook.c
// Function: glXSwapIntervalMESA
extern int glXSwapIntervalMESA(unsigned int interval)
{
	int signed_interval;
	if (interval > (unsigned)INT_MAX) {
		signed_interval=INT_MAX;
	} else {
		signed_interval=(int)interval;
	}
	signed_interval=GH_swap_interval(signed_interval);
	if (signed_interval == GH_SWAP_DONT_SET) {
		/* ignore the call */
		return 0; /* success */
	}
	if (signed_interval < 0) {
		GH_verbose(GH_MSG_WARNING,"glXSwapIntervalMESA does not support negative swap intervals\n");
		interval=(unsigned)(-signed_interval);
	} else {
		interval=(unsigned)signed_interval;
	}
	GH_GET_PTR_GL(glXSwapIntervalMESA);
	return GH_glXSwapIntervalMESA(interval);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpl %eax, %edi
cmovael %eax, %edi
callq 0x1acf
movl %eax, %ebp
negl %ebp
jno 0x1ebf
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %eax, %ebx
testl %eax, %eax
jns 0x1ed8
leaq 0x207(%rip), %rsi       # 0x20d3
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x1677
movl %ebp, %ebx
leaq 0x21e9(%rip), %rdi      # 0x40c8
callq 0x1120
cmpq $0x0, 0x222c(%rip)      # 0x4118
jne 0x1f01
leaq 0x21c(%rip), %rdi       # 0x2111
callq 0x1d65
movq %rax, 0x2217(%rip)      # 0x4118
leaq 0x21c0(%rip), %rdi      # 0x40c8
callq 0x10c0
movq 0x2204(%rip), %rax      # 0x4118
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/winton[P]redis_parse/hiredis/net.c
// Function: redisCheckSocketError
int redisCheckSocketError(redisContext *c, int fd) {
    int err = 0;
    socklen_t errlen = sizeof(err);

    if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &errlen) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"getsockopt(SO_ERROR)");
        close(fd);
        return REDIS_ERR;
    }

    if (err) {
        errno = err;
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
        close(fd);
        return REDIS_ERR;
    }

    return REDIS_OK;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rcx
andl $0x0, (%rcx)
movl %esi, %ebx
movq %rdi, %r14
leaq 0xc(%rsp), %r8
movl $0x4, (%r8)
pushq $0x1
popq %rsi
pushq $0x4
popq %rdx
movl %ebx, %edi
callq 0x2250
cmpl $-0x1, %eax
je 0x25c5
movl 0x8(%rsp), %ebp
testl %ebp, %ebp
je 0x25e0
callq 0x2080
movl %ebp, (%rax)
movq %r14, %rdi
xorl %esi, %esi
jmp 0x25cf
leaq 0x4a34(%rip), %rsi      # 0x7000
movq %r14, %rdi
callq 0x25eb
movl %ebx, %edi
callq 0x21e0
pushq $-0x1
popq %rax
jmp 0x25e2
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/winton[P]redis_parse/hiredis/net.c
// Function: redisSetBlocking
static int redisSetBlocking(redisContext *c, int fd, int blocking) {
    int flags;

    /* Set the socket nonblocking.
     * Note that fcntl(2) for F_GETFL and F_SETFL can't be
     * interrupted by a signal. */
    if ((flags = fcntl(fd, F_GETFL)) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"fcntl(F_GETFL)");
        close(fd);
        return REDIS_ERR;
    }

    if (blocking)
        flags &= ~O_NONBLOCK;
    else
        flags |= O_NONBLOCK;

    if (fcntl(fd, F_SETFL, flags) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"fcntl(F_SETFL)");
        close(fd);
        return REDIS_ERR;
    }
    return REDIS_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
pushq $0x3
popq %rsi
movl %ebx, %edi
xorl %eax, %eax
callq 0x2100
cmpl $-0x1, %eax
je 0x28e6
xorl %edx, %edx
testl %r15d, %r15d
sete %dl
andl $0xfffff7ff, %eax       # imm = 0xFFFFF7FF
shll $0xb, %edx
orl %eax, %edx
pushq $0x4
popq %rsi
movl %ebx, %edi
xorl %eax, %eax
callq 0x2100
cmpl $-0x1, %eax
jne 0x28ff
leaq 0x4790(%rip), %rsi      # 0x7074
jmp 0x28ed
leaq 0x4778(%rip), %rsi      # 0x7065
movq %r14, %rdi
callq 0x25eb
movl %ebx, %edi
callq 0x21e0
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/winton[P]redis_parse/hiredis/net.c
// Function: redisContextWaitReady
static int redisContextWaitReady(redisContext *c, int fd, const struct timeval *timeout) {
    struct timeval to;
    struct timeval *toptr = NULL;
    fd_set wfd;

    /* Only use timeout when not NULL. */
    if (timeout != NULL) {
        to = *timeout;
        toptr = &to;
    }

    if (errno == EINPROGRESS) {
        FD_ZERO(&wfd);
        FD_SET(fd, &wfd);

        if (select(FD_SETSIZE, NULL, &wfd, NULL, toptr) == -1) {
            __redisSetErrorFromErrno(c,REDIS_ERR_IO,"select(2)");
            close(fd);
            return REDIS_ERR;
        }

        if (!FD_ISSET(fd, &wfd)) {
            errno = ETIMEDOUT;
            __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
            close(fd);
            return REDIS_ERR;
        }

        if (redisCheckSocketError(c, fd) != REDIS_OK)
            return REDIS_ERR;

        return REDIS_OK;
    }

    __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
    close(fd);
    return REDIS_ERR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %esi, %ebx
movq %rdi, %r14
testq %rdx, %rdx
je 0x2934
movups (%rdx), %xmm0
movq %rsp, %r12
movaps %xmm0, (%r12)
jmp 0x2937
xorl %r12d, %r12d
callq 0x2080
cmpl $0x73, (%rax)
jne 0x29bd
movq %rax, %r15
xorl %eax, %eax
cmpq $0x10, %rax
je 0x2957
andq $0x0, 0x18(%rsp,%rax,8)
incq %rax
jmp 0x2946
pushq $0x40
popq %rcx
movl %ebx, %eax
cltd
idivl %ecx
movslq %eax, %r13
shll $0x6, %eax
movl %ebx, %ecx
subl %eax, %ecx
pushq $0x1
popq %rbp
shlq %cl, %rbp
orq %rbp, 0x18(%rsp,%r13,8)
leaq 0x18(%rsp), %rdx
movl $0x400, %edi            # imm = 0x400
xorl %esi, %esi
xorl %ecx, %ecx
movq %r12, %r8
callq 0x22d0
cmpl $-0x1, %eax
je 0x29aa
testq %rbp, 0x18(%rsp,%r13,8)
je 0x29b6
movq %r14, %rdi
movl %ebx, %esi
callq 0x2150
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
jmp 0x29d1
leaq 0x46d2(%rip), %rsi      # 0x7083
movq %r14, %rdi
jmp 0x29c2
movl $0x6e, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x25eb
movl %ebx, %edi
callq 0x21e0
pushq $-0x1
popq %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq