LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_int_suffixes(token&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
void parse_int_suffixes(token &r,string::iterator &li,const string::iterator lie) {
    if (strit_next_match_inc(li,lie,'u'))
        r.i.sign = false;
    else if (strit_next_match_inc(li,lie,'U'))
        r.i.sign = false;

    if (strit_next_match_inc(li,lie,'i','6','4'))
        r.bsize = 64; /* long long */
    else if (strit_next_match_inc(li,lie,'I','6','4'))
        r.bsize = 64; /* long long */
    else if (strit_next_match_inc(li,lie,'l','l'))
        r.bsize = 64; /* long long */
    else if (strit_next_match_inc(li,lie,'L','L'))
        r.bsize = 64; /* long long */
    else if (strit_next_match_inc(li,lie,'l'))
        r.bsize = 32; /* long */
    else if (strit_next_match_inc(li,lie,'L'))
        r.bsize = 32; /* long */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
cmpq %rdx, %rax
je 0x3de7
cmpb $0x75, (%rax)
je 0x3ddd
cmpb $0x55, (%rax)
jne 0x3de7
incq %rax
movq %rax, (%r14)
movb $0x0, 0x10(%rbx)
pushq $0x69
popq %rdx
pushq $0x36
popq %rcx
pushq $0x34
popq %r8
movq %r14, %rdi
movq %r15, %rsi
callq 0x3e6e
movb $0x40, %bpl
testb %al, %al
jne 0x3e5f
pushq $0x49
popq %rdx
pushq $0x36
popq %rcx
pushq $0x34
popq %r8
movq %r14, %rdi
movq %r15, %rsi
callq 0x3e6e
testb %al, %al
jne 0x3e5f
pushq $0x6c
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
movl %ecx, %edx
callq 0x3ea2
testb %al, %al
jne 0x3e5f
pushq $0x4c
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
movl %ecx, %edx
callq 0x3ea2
testb %al, %al
jne 0x3e5f
movq (%r14), %rax
cmpq %r15, %rax
je 0x3e63
cmpb $0x6c, (%rax)
je 0x3e56
cmpb $0x4c, (%rax)
jne 0x3e63
incq %rax
movq %rax, (%r14)
movb $0x20, %bpl
movb %bpl, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/joncampbell123[P]haxcc/haxpp.cpp
// Function: strit_next_match_inc(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char, char, char)
static inline bool strit_next_match_inc(string::iterator &ti,const string::iterator lie,const char c,const char c2,const char c3) {
    auto tmp = ti;

    if (tmp != lie && *tmp == c) {
        tmp++;
        if (tmp != lie && *tmp == c2) {
            tmp++;
            if (tmp != lie && *tmp == c3) {
                tmp++;
                ti = tmp;
                return true;
            }
        }
    }

    return false;
}

// Assembly:
movq (%rdi), %rax
cmpq %rsi, %rax
je 0x3e9f
cmpb %dl, (%rax)
jne 0x3e9f
leaq 0x1(%rax), %rdx
cmpq %rsi, %rdx
je 0x3e9f
cmpb %cl, (%rdx)
jne 0x3e9f
leaq 0x2(%rax), %rcx
cmpq %rsi, %rcx
je 0x3e9f
cmpb %r8b, (%rcx)
jne 0x3e9f
addq $0x3, %rax
movq %rax, (%rdi)
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/joncampbell123[P]haxcc/haxpp.cpp
// Function: strit_next_match_inc(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char, char)
static inline bool strit_next_match_inc(string::iterator &ti,const string::iterator lie,const char c,const char c2) {
    auto tmp = ti;

    if (tmp != lie && *tmp == c) {
        tmp++;
        if (tmp != lie && *tmp == c2) {
            tmp++;
            ti = tmp;
            return true;
        }
    }

    return false;
}

// Assembly:
movq (%rdi), %rax
cmpq %rsi, %rax
je 0x3ec5
cmpb %dl, (%rax)
jne 0x3ec5
leaq 0x1(%rax), %rdx
cmpq %rsi, %rdx
je 0x3ec5
cmpb %cl, (%rdx)
jne 0x3ec5
addq $0x2, %rax
movq %rax, (%rdi)
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_number_looks_like_float(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
bool parse_number_looks_like_float(string::iterator /*does not modify caller copy*/li,const string::iterator lie) {
    if (strit_next_match_inc(li,lie,'0','x')) {
        while (li != lie && isxdigit(*li)) li++;
        if (li != lie) return (*li == '.' || *li == 'p' || *li == 'p');
    }
    else {
        while (li != lie && isdigit(*li)) li++;
        if (li != lie) return (*li == '.' || *li == 'e' || *li == 'E');
    }

    return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, %rdi
je 0x42ce
cmpb $0x30, (%r14)
jne 0x42ce
leaq 0x1(%r14), %rax
cmpq %rbx, %rax
je 0x42ce
cmpb $0x78, (%rax)
jne 0x42ce
addq $0x2, %r14
cmpq %rbx, %r14
je 0x42f9
movb (%r14), %bpl
movsbl %bpl, %edi
callq 0x2060
incq %r14
testl %eax, %eax
jne 0x42a4
cmpb $0x2e, %bpl
sete %cl
cmpb $0x70, %bpl
sete %al
orb %cl, %al
jmp 0x42fb
cmpq %rbx, %r14
je 0x42f9
movsbl (%r14), %ecx
leal -0x30(%rcx), %eax
incq %r14
cmpl $0xa, %eax
jb 0x42ce
addb $-0x2e, %cl
cmpb $0x37, %cl
ja 0x42f9
movabsq $0x80000000800001, %rax # imm = 0x80000000800001
shrq %cl, %rax
jmp 0x42fb
xorl %eax, %eax
andb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_identifier(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
string parse_identifier(string::iterator &li,const string::iterator lie) {
    string r;

    if (li == lie) throw invalid_argument("expected identifier, got end of line");
    if (!isidentifier_fc(*li)) throw invalid_argument("expected identifier");

    do {
        r += *(li++);
        if (li == lie) break;
        if (!isidentifier_mc(*li)) break;
    } while (1);

    return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %r12
cmpq %rdx, %r12
je 0x46f2
movq %rdx, %r14
movq %rsi, %r15
movsbl (%r12), %edi
callq 0x3658
testb %al, %al
je 0x470e
leaq 0x1(%r12), %rax
movq %rax, (%r15)
movsbl (%r12), %esi
movq %rbx, %rdi
callq 0x2190
movq (%r15), %r12
cmpq %r14, %r12
je 0x46e3
movsbl (%r12), %edi
callq 0x366f
testb %al, %al
jne 0x46b8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %r14
leaq 0xb4bb(%rip), %rsi      # 0xfbbf
movq %rax, %rdi
callq 0x23a0
jmp 0x4728
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %r14
leaq 0xb4c4(%rip), %rsi      # 0xfbe4
movq %rax, %rdi
callq 0x23a0
movq 0x138a9(%rip), %rsi     # 0x17fd8
movq 0x1388a(%rip), %rdx     # 0x17fc0
movq %r14, %rdi
callq 0x2340
jmp 0x4740
movq %rax, %r15
movq %r14, %rdi
callq 0x2160
jmp 0x4752
jmp 0x474f
movq %rax, %r15
movq %rbx, %rdi
callq 0x2408
movq %r15, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/joncampbell123[P]haxcc/haxpp.cpp
// Function: to_string_pp[abi:cxx11](token const&)
string to_string_pp(const token &t) {
    switch (t.tval) {
        case token::MACRO:
            return t.sval + " ";
        case token::PREPROC:
            return "";
        case token::MACROSUBST:
            return t.sval + " ";
        case token::IDENTIFIER:
            return t.sval + " ";
        case token::MACROPARAM:
            return "";
        case token::INTEGER:
            return to_string(t.i.s) + " ";
        case token::FLOAT:
            return a_better_float_to_string(t.f.get_double()) + " ";
        case token::STRING:
            return string("\"") + string_store.get_char(t.s.strref) + string("\"") + " ";
        default:
            break;
    };

    return to_string(t);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
decl %eax
cmpl $0xa, %eax
ja 0x516c
leaq 0xa2c2(%rip), %rcx      # 0xf3cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x48, %r14
leaq 0xab11(%rip), %rdx      # 0xfc2f
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb3a2
jmp 0x5252
leaq 0xb16b(%rip), %rsi      # 0x102a0
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0xb1b8
jmp 0x5252
movq 0x8(%r14), %rsi
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0xb32b
leaq 0xaad0(%rip), %rdx      # 0xfc2f
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb244
jmp 0x51aa
movq %rbx, %rdi
movq %r14, %rsi
callq 0x47a7
jmp 0x5252
addq $0x20, %r14
movq %r14, %rdi
callq 0xb38c
fstpt (%rsp)
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x4762
leaq 0xaa90(%rip), %rdx      # 0xfc2f
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb244
leaq 0x18(%rsp), %rdi
jmp 0x524d
leaq 0xaa71(%rip), %rsi      # 0xfc2c
leaq 0x58(%rsp), %rdi
leaq 0x17(%rsp), %rdx
callq 0xb1b8
movq 0x40(%r14), %rsi
leaq 0x1307b(%rip), %rdi     # 0x18250
callq 0x268c
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
movq %rax, %rdx
callq 0xb263
leaq 0xaa39(%rip), %rsi      # 0xfc2c
leaq 0x38(%rsp), %rdi
leaq 0x16(%rsp), %rdx
callq 0xb1b8
leaq 0x18(%rsp), %rdi
leaq 0x78(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0xb282
leaq 0xaa12(%rip), %rdx      # 0xfc2f
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0xb244
leaq 0x18(%rsp), %rdi
callq 0x2408
leaq 0x38(%rsp), %rdi
callq 0x2408
leaq 0x78(%rsp), %rdi
callq 0x2408
leaq 0x58(%rsp), %rdi
callq 0x2408
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2408
jmp 0x5272
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x2408
jmp 0x5281
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x2408
jmp 0x52a1
movq %rax, %rbx
jmp 0x52ab
jmp 0x5294
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0x52a6
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x2408
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/joncampbell123[P]haxcc/haxpp.cpp
// Function: print_token(_IO_FILE*, token const&)
void print_token(FILE *fp,const token &t) {
    if (fp == NULL)
        fp = stderr;

    const string s = to_string(t);
    fputs(s.c_str(),fp);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x52cc
movq 0x12cef(%rip), %rax     # 0x17fb8
movq (%rax), %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x47a7
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x2200
movq %r14, %rdi
callq 0x2408
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/joncampbell123[P]haxcc/haxpp.cpp
// Function: do_macro_expand_read_invoke_param(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, bool)
string do_macro_expand_read_invoke_param(string::iterator &li,const string::iterator lie,bool final_variadic=false) {
    int paren = 0;
    string r;

    do {
        if (li == lie)
            throw invalid_argument("string terminated unexpectedly");
        if (*li == '(') {
            paren++;
        }
        else if (*li == ')') {
            if (paren > 0)
                paren--;
            else
                break;
        }
        else if (*li == ',' && !final_variadic) {
            break;
        }

        r += *(li++);
    } while (1);

    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r15
movb $0x0, 0x10(%rdi)
xorl %r12d, %r12d
xorb $0x1, %bpl
movq (%r15), %rax
cmpq %r14, %rax
je 0x536d
movzbl (%rax), %ecx
cmpl $0x29, %ecx
je 0x5338
cmpl $0x28, %ecx
jne 0x5342
incl %r12d
jmp 0x534d
testl %r12d, %r12d
jle 0x5361
decl %r12d
jmp 0x534d
cmpb $0x2c, %cl
sete %cl
testb %bpl, %cl
jne 0x5361
leaq 0x1(%rax), %rcx
movq %rcx, (%r15)
movsbl (%rax), %esi
movq %rbx, %rdi
callq 0x2190
jmp 0x531e
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %r15
leaq 0xab9b(%rip), %rsi      # 0xff1a
movq %rax, %rdi
callq 0x23a0
movq 0x12c4a(%rip), %rsi     # 0x17fd8
movq 0x12c2b(%rip), %rdx     # 0x17fc0
movq %r15, %rdi
callq 0x2340
jmp 0x53ac
movq %rax, %r14
movq %r15, %rdi
callq 0x2160
jmp 0x53af
movq %rax, %r14
movq %rbx, %rdi
callq 0x2408
movq %r14, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/joncampbell123[P]haxcc/haxpp.cpp
// Function: pp_stringify(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string pp_stringify(const string &s) {
    string r;

    r += '\"';
    for (auto si=s.begin();si!=s.end();si++) {
        if (*si == '\'' || *si == '\"' || *si == '\\') r += '\\';
        r += *si;
    }
    r += '\"';

    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
pushq $0x22
popq %rsi
callq 0x2190
movq (%r14), %rax
movabsq $0x400000000000021, %r15 # imm = 0x400000000000021
pushq $0x5c
popq %rbp
movq %rax, %r12
addq 0x8(%r14), %rax
cmpq %rax, %r12
je 0x5437
movzbl (%r12), %eax
movl %eax, %ecx
addl $-0x22, %ecx
cmpl $0x3a, %ecx
ja 0x5424
btq %rcx, %r15
jae 0x5424
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2190
movb (%r12), %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2190
incq %r12
movq (%r14), %rax
jmp 0x53f8
pushq $0x22
popq %rsi
movq %rbx, %rdi
callq 0x2190
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5450
movq %rax, %r14
movq %rbx, %rdi
callq 0x2408
movq %r14, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/joncampbell123[P]haxcc/haxpp.cpp
// Function: expression::newnode(token const&)
expression::node::node_t expression::newnode(const token &nt) {
    const node::node_t r = nodelist.size();
    nodelist.resize(r+size_t(1));
    nodelist[r].tval = nt;
    return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
subq (%rdi), %r15
movl $0x90, %ecx
movq %r15, %rax
cqto
idivq %rcx
movq %rax, %r12
leaq 0x1(%rax), %rsi
callq 0xb44a
addq (%r14), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xb484
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/joncampbell123[P]haxcc/haxpp.cpp
// Function: expression::newnode(token const&, token::token_t)
expression::node::node_t expression::newnode(const token &nt,const token::token_t ntval) {
    const node::node_t r = nodelist.size();
    nodelist.resize(r+size_t(1));
    nodelist[r].tval = nt;
    nodelist[r].tval.tval = ntval;
    return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %r12
subq (%rdi), %r12
movl $0x90, %ecx
movq %r12, %rax
cqto
idivq %rcx
movq %rax, %r13
leaq 0x1(%rax), %rsi
callq 0xb44a
movq (%r15), %rdi
addq %r12, %rdi
movq %r14, %rsi
callq 0xb484
movq (%r15), %rax
movl %ebx, (%rax,%r12)
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/joncampbell123[P]haxcc/haxpp.cpp
// Function: match_token_list(token::token_t&, token const&, tokenlist_entry const*)
bool match_token_list(token::token_t &repl,const token &t,const tokenlist_entry *tokens) {
    while (tokens->match != token::NONE) {
        if (t.tval == tokens->match) {
            repl = tokens->replace;
            return true;
        }

        tokens++;
    }

    return false;
}

// Assembly:
movl (%rsi), %eax
addq $0x4, %rdx
movl -0x4(%rdx), %ecx
testl %ecx, %ecx
je 0x884e
cmpl %ecx, %eax
je 0x884a
addq $0x8, %rdx
jmp 0x8839
movl (%rdx), %eax
movl %eax, (%rdi)
testl %ecx, %ecx
setne %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_expr_rtl(expression&, __gnu_cxx::__normal_iterator<token*, std::vector<token, std::allocator<token>>>&, __gnu_cxx::__normal_iterator<token*, std::vector<token, std::allocator<token>>> const&, unsigned int, tokenlist_entry const*, unsigned long)
expression::node::node_t parse_expr_rtl(expression &expr,token_string::iterator &ti,const token_string::iterator &tie,unsigned int min_prec,const tokenlist_entry *match_token,expression::node::node_t headnode) {
    token::token_t repl;
    unsigned int prec;

    while (ti != tie && match_token_list(/*&*/repl,*ti,match_token) && (prec=token::precedence(*ti,false)) <= min_prec) {
        const expression::node::node_t opnode = expr.newnode(*(ti++),repl);

        if (ti != tie) {
            expr.getnode(opnode).children.resize(2);
            expr.getnode(opnode).children[0] = headnode;
            expr.getnode(opnode).children[1] = parse_expr(expr,ti,tie,prec);
            headnode = opnode;
        }
        else {
            throw invalid_argument("missing rvalue");
        }
    }

    return headnode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbp
movq %r8, 0x10(%rsp)
movl %ecx, (%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%r15), %r13
cmpq (%r14), %r13
je 0x8d44
leaq 0x4(%rsp), %rdi
movq %r13, %rsi
movq 0x10(%rsp), %rdx
callq 0x8833
testb %al, %al
je 0x8d44
movq %r13, %rdi
xorl %esi, %esi
callq 0x270e
cmpl (%rsp), %eax
ja 0x8d44
movl %eax, %ebx
leaq 0x70(%r13), %rax
movq %rax, (%r15)
movl 0x4(%rsp), %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x87e0
movq %rax, 0x8(%rsp)
movq (%r15), %rax
cmpq (%r14), %rax
je 0x8d56
movq %r12, %rdi
leaq 0x8(%rsp), %r13
movq %r13, %rsi
callq 0xb4a6
leaq 0x70(%rax), %rdi
pushq $0x2
popq %rsi
callq 0xb51e
movq %r12, %rdi
movq %r13, %rsi
callq 0xb4a6
movq 0x70(%rax), %rax
movq %rbp, (%rax)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x895f
movq %rax, %rbx
movq %r12, %rdi
movq %r13, %rsi
callq 0xb4a6
movq 0x70(%rax), %rax
movq %rbx, 0x8(%rax)
movq 0x8(%rsp), %rbp
jmp 0x8c88
movq %rbp, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x74ac(%rip), %rsi      # 0x10214
movq %rax, %rdi
callq 0x23a0
movq 0xf261(%rip), %rsi      # 0x17fd8
movq 0xf242(%rip), %rdx      # 0x17fc0
movq %rbx, %rdi
callq 0x2340
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_expr_ltr_unary(expression&, __gnu_cxx::__normal_iterator<token*, std::vector<token, std::allocator<token>>>&, __gnu_cxx::__normal_iterator<token*, std::vector<token, std::allocator<token>>> const&, unsigned int, tokenlist_entry const*, unsigned long)
expression::node::node_t parse_expr_ltr_unary(expression &expr,token_string::iterator &ti,const token_string::iterator &tie,unsigned int min_prec,const tokenlist_entry *match_token,expression::node::node_t headnode) {
    token::token_t repl;
    unsigned int prec;

    while (ti != tie && match_token_list(/*&*/repl,*ti,match_token) && (prec=token::precedence(*ti,false)) <= min_prec) {
        const expression::node::node_t opnode = expr.newnode(*(ti++),repl);

        expr.getnode(opnode).children.resize(1);
        expr.getnode(opnode).children[0] = headnode;
        headnode = opnode;
    }

    return headnode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, %r14
movl %ecx, 0x8(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq (%r12), %rbp
cmpq (%r15), %rbp
je 0x8e38
leaq 0xc(%rsp), %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x8833
testb %al, %al
je 0x8e38
movq %rbp, %rdi
xorl %esi, %esi
callq 0x270e
cmpl 0x8(%rsp), %eax
ja 0x8e38
leaq 0x70(%rbp), %rax
movq %rax, (%r12)
movl 0xc(%rsp), %edx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x87e0
movq %rax, 0x10(%rsp)
movq %r13, %rdi
leaq 0x10(%rsp), %rbp
movq %rbp, %rsi
callq 0xb4a6
leaq 0x70(%rax), %rdi
pushq $0x1
popq %rsi
callq 0xb51e
movq %r13, %rdi
movq %rbp, %rsi
callq 0xb4a6
movq 0x70(%rax), %rax
movq %rbx, (%rax)
movq 0x10(%rsp), %rbx
jmp 0x8dba
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_expr_ltr(expression&, __gnu_cxx::__normal_iterator<token*, std::vector<token, std::allocator<token>>>&, __gnu_cxx::__normal_iterator<token*, std::vector<token, std::allocator<token>>> const&, unsigned int, tokenlist_entry const*, unsigned long)
expression::node::node_t parse_expr_ltr(expression &expr,token_string::iterator &ti,const token_string::iterator &tie,unsigned int min_prec,const tokenlist_entry *match_token,expression::node::node_t headnode) {
    token::token_t repl;
    unsigned int prec;

    while (ti != tie && match_token_list(repl,*ti,match_token) && (prec=token::precedence(*ti,false)) <= min_prec) {
        const expression::node::node_t opnode = expr.newnode(*(ti++),repl);

        if (ti != tie) {
            expr.getnode(opnode).children.resize(2);
            expr.getnode(opnode).children[0] = headnode;
            expr.getnode(opnode).children[1] = parse_expr(expr,ti,tie,prec-1u);
            headnode = opnode;
        }
        else {
            throw invalid_argument("missing rvalue");
        }
    }

    return headnode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbp
movq %r8, 0x10(%rsp)
movl %ecx, (%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%r15), %r13
cmpq (%r14), %r13
je 0x8f2a
leaq 0x4(%rsp), %rdi
movq %r13, %rsi
movq 0x10(%rsp), %rdx
callq 0x8833
testb %al, %al
je 0x8f2a
movq %r13, %rdi
xorl %esi, %esi
callq 0x270e
cmpl (%rsp), %eax
ja 0x8f2a
movl %eax, %ebx
leaq 0x70(%r13), %rax
movq %rax, (%r15)
movl 0x4(%rsp), %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x87e0
movq %rax, 0x8(%rsp)
movq (%r15), %rax
cmpq (%r14), %rax
je 0x8f3c
movq %r12, %rdi
leaq 0x8(%rsp), %r13
movq %r13, %rsi
callq 0xb4a6
leaq 0x70(%rax), %rdi
pushq $0x2
popq %rsi
callq 0xb51e
movq %r12, %rdi
movq %r13, %rsi
callq 0xb4a6
movq 0x70(%rax), %rax
movq %rbp, (%rax)
decl %ebx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x895f
movq %rax, %rbx
movq %r12, %rdi
movq %r13, %rsi
callq 0xb4a6
movq 0x70(%rax), %rax
movq %rbx, 0x8(%rax)
movq 0x8(%rsp), %rbp
jmp 0x8e6c
movq %rbp, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x72c6(%rip), %rsi      # 0x10214
movq %rax, %rdi
callq 0x23a0
movq 0xf07b(%rip), %rsi      # 0x17fd8
movq 0xf05c(%rip), %rdx      # 0x17fc0
movq %rbx, %rdi
callq 0x2340
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/joncampbell123[P]haxcc/haxpp.cpp
// Function: dump_expr_node(_IO_FILE*, expression const&, unsigned long, unsigned int)
void dump_expr_node(FILE *fp,const expression &expr,const expression::node::node_t node,unsigned int depth) {
    if (fp == NULL)
        fp = stderr;

    for (unsigned int c=0;c < depth;c++)
        fprintf(fp,"| ");

    fprintf(fp,"node[%zu]: %s\n",node,to_string(expr.getnode(node).tval).c_str());
    for (size_t i=0;i < expr.getnode(node).children.size();i++)
        dump_expr_node(fp,expr,expr.getnode(node).children[i],depth+1u);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
testq %rdi, %rdi
jne 0x9516
movq 0xeaa5(%rip), %rax      # 0x17fb8
movq (%rax), %r15
leaq 0x6892(%rip), %r12      # 0xfdaf
pushq $0x2
popq %rbp
pushq $0x1
popq %r13
movl %ebx, 0x4(%rsp)
subl $0x1, %ebx
jb 0x9540
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x23d0
jmp 0x9528
leaq 0x10(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0xb550
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0x47a7
movq (%r13), %rcx
leaq 0x6d1a(%rip), %rsi      # 0x10285
xorl %ebp, %ebp
movq %r15, %rdi
movq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x2290
movq %r13, %rdi
callq 0x2408
movl 0x4(%rsp), %ebx
incl %ebx
movq %r14, %rdi
movq %r12, %rsi
callq 0xb550
movq 0x78(%rax), %rcx
subq 0x70(%rax), %rcx
sarq $0x3, %rcx
cmpq %rcx, %rbp
jae 0x95cb
movq %r14, %rdi
movq %r12, %rsi
callq 0xb550
movq 0x70(%rax), %rax
movq (%rax,%rbp,8), %rdx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %ecx
callq 0x94e7
incq %rbp
jmp 0x958a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/joncampbell123[P]haxcc/haxpp.cpp
// Function: dump_expr(_IO_FILE*, expression const&)
void dump_expr(FILE *fp,const expression &expr) {
    if (fp == NULL)
        fp = stderr;

    fprintf(fp,"expression:\n");
    if (expr.root != expression::node::none)
        dump_expr_node(fp,expr,expr.root,1);
    fprintf(fp,"END\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x95f3
movq 0xe9c8(%rip), %rax      # 0x17fb8
movq (%rax), %rbx
leaq 0x6c9a(%rip), %rdi      # 0x10294
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x23d0
movq 0x18(%r14), %rdx
cmpq $-0x1, %rdx
je 0x9620
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x94e7
leaq 0x6c7a(%rip), %rdi      # 0x102a1
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/joncampbell123[P]haxcc/haxpp.cpp
// Function: expression::getnode(unsigned long const&)
inline node& getnode(const node::node_t &n) {
            if (n < nodelist.size())
                return nodelist[n];
            else
                throw runtime_error("node out of range");
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rsi), %rsi
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
subq %rcx, %rax
movl $0x90, %edi
cqto
idivq %rdi
cmpq %rax, %rsi
jae 0xb4db
imulq $0x90, %rsi, %rax
addq %rax, %rcx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x525a(%rip), %rsi      # 0x10747
movq %rax, %rdi
callq 0x20a0
movq 0xcafc(%rip), %rsi      # 0x17ff8
movq 0xcaad(%rip), %rdx      # 0x17fb0
movq %rbx, %rdi
callq 0x2340
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/joncampbell123[P]haxcc/haxpp.cpp
// Function: FileSourceStack::pop()
void pop() {
        if (stkpos >= 0) {
            src[stkpos].close();
            stkpos--;
        }
        else {
            throw underflow_error("FileSourceStack stack underflow");
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rax
testq %rax, %rax
js 0xb842
movq %rdi, %rbx
imulq $0x38, %rax, %rdi
addq (%rbx), %rdi
callq 0x2a34
decq 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x4fdf(%rip), %rsi      # 0x10833
movq %rax, %rdi
callq 0x23f0
movq 0xc745(%rip), %rsi      # 0x17fa8
movq 0xc786(%rip), %rdx      # 0x17ff0
movq %rbx, %rdi
callq 0x2340
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O2/ashlall[P]StreamStats/Test/./../SourceCode/BasicStats/BasicStats.cpp
// Function: BasicStats::insert(double)
void BasicStats::insert(double num)
{
  stream_size++; 
  sum = sum + num;
  squaredsum += num * num;
  min = if_MIN(num);
  max = if_MAX(num);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x20(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rdi)
movsd (%rdi), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rdi)
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
addsd 0x8(%rdi), %xmm1
movsd %xmm1, 0x8(%rdi)
movapd %xmm0, %xmm2
testq %rax, %rax
je 0x126b
minsd 0x10(%rdi), %xmm2
movsd 0x18(%rdi), %xmm1
jmp 0x126f
movapd %xmm0, %xmm1
movsd %xmm2, 0x10(%rdi)
movapd %xmm1, %xmm2
cmplesd %xmm0, %xmm2
andpd %xmm2, %xmm0
andnpd %xmm1, %xmm2
orpd %xmm0, %xmm2
movlpd %xmm2, 0x18(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ashlall[P]StreamStats/Test/BasicStats_test.cpp
// Function: test_SD()
void test_SD()
{
  BasicStats a; // tests with 10 items in the stream in ascending order
  for (int i=1;i<=10;i++)
    a.insert(i);
  assert(3.02765 <= a.SD() <= 3.0275);

  for (int i=100;i>=11;i--) // tests with 100 items in the stream in descending order
    a.insert(i);
  assert(29.01149<=a.SD()<=29.01149);

  a.insert(1000); // tests adding an outlier to the stream
  assert(98.79013<=a.SD()<=98.79013);

  for (int i=1;i<10;i++) // tests having 10 max values in the stream
    a.insert(1000);
  assert(275.6017<=a.SD()<=275.6017);

  BasicStats b; // tests with father apart integers
  for (int i=1;i<=50;i++)
    b.insert(i*3);
  assert(43.73214<=b.SD()<=43.73214);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rbx
movaps %xmm0, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
movaps %xmm0, (%rbx)
movsd 0x56a(%rip), %xmm0      # 0x2010
pushq $0xa
popq %r14
subl $0x1, %r14d
jb 0x1ad1
movq %rbx, %rdi
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x1228
movsd -0x18(%rbp), %xmm0
addsd 0x541(%rip), %xmm0      # 0x2010
jmp 0x1aaa
leaq -0x40(%rbp), %rbx
movq %rbx, %rdi
callq 0x1314
pushq $0x64
popq %r14
cmpl $0xa, %r14d
jbe 0x1af9
cvtsi2sd %r14d, %xmm0
movq %rbx, %rdi
callq 0x1228
decl %r14d
jmp 0x1ae1
leaq -0x40(%rbp), %rbx
movq %rbx, %rdi
callq 0x1314
movsd 0x553(%rip), %xmm0      # 0x2060
movq %rbx, %rdi
callq 0x1228
movq %rbx, %rdi
callq 0x1314
pushq $0x9
popq %r14
subl $0x1, %r14d
jb 0x1b39
movq %rbx, %rdi
movsd 0x52e(%rip), %xmm0      # 0x2060
callq 0x1228
jmp 0x1b21
leaq -0x40(%rbp), %rdi
callq 0x1314
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %rbx
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
andq $0x0, 0x20(%rbx)
pushq $0x3
popq %r14
cmpl $0x99, %r14d
je 0x1b75
cvtsi2sd %r14d, %xmm0
movq %rbx, %rdi
callq 0x1228
addl $0x3, %r14d
jmp 0x1b59
leaq -0x70(%rbp), %rdi
callq 0x1314
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ashlall[P]StreamStats/Test/BasicStats_test.cpp
// Function: main
int main()
{
  test_Average();
  test_MIN();
  test_MAX();
  test_SD();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x1866
callq 0x135c
callq 0x15e1
callq 0x1a80
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/./tsv.hpp
// Function: Common_sp::TsvOut& Common_sp::TsvOut::operator<<<unsigned long>(unsigned long const&)
TsvOut& operator<< (const T &field)
      { if (os)
        { if (lines && fields >= fields_max)
            throw runtime_error ("TsvOut: fields_max = " + to_string (fields_max));
          if (fields)  
            *os << '\t'; 
          else if (! lines && usePound)
            *os << '#';
          *os << field; 
          fields++;
        }
        return *this; 
      }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x11823
movq %rsi, %rbx
cmpq $0x0, 0x10(%r14)
movq 0x20(%r14), %rcx
je 0x117fc
cmpq 0x18(%r14), %rcx
jae 0x1182f
movb $0x9, %al
testq %rcx, %rcx
jne 0x1180c
jmp 0x11814
movb $0x9, %al
testq %rcx, %rcx
jne 0x1180c
movb $0x23, %al
cmpb $0x1, 0x28(%r14)
jne 0x11814
movzbl %al, %esi
callq 0xb630
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0xb3e0
incq 0x20(%r14)
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xb2e0
movq %rax, %rbx
movq 0x18(%r14), %rsi
movq %rsp, %rdi
callq 0x10e1e
leaq 0x38d6e(%rip), %rsi     # 0x4a5bb
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x11682
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xb8d0
xorl %ebp, %ebp
movq 0x5b77d(%rip), %rsi     # 0x6cff0
movq 0x5b6ee(%rip), %rdx     # 0x6cf68
movq %rbx, %rdi
callq 0xb970
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xbb18
jmp 0x11897
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0xbb18
testb %bpl, %bpl
jne 0x118a9
jmp 0x118b1
movq %rax, %r14
movq %rbx, %rdi
callq 0xb430
movq %r14, %rdi
callq 0xb9d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/./tsv.hpp
// Function: Common_sp::TsvOut::newLn()
void newLn ()
    { if (! os)
        return;
      *os << endl;
      if (! lines)
        fields_max = fields;
      lines++;
      if (fields != fields_max)
        throw runtime_error ("TsvOut: fields_max = " + to_string (fields_max) + ", but fields = " + to_string (fields));
      fields = 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x11606
callq 0xb2d0
movq 0x10(%r14), %rdx
movq 0x20(%r14), %rax
leaq 0x1(%rdx), %rcx
testq %rdx, %rdx
je 0x115f9
movq %rcx, 0x10(%r14)
cmpq 0x18(%r14), %rax
je 0x11601
pushq $0x10
popq %rdi
callq 0xb2e0
movq %rax, %rbx
movq 0x18(%r14), %rsi
leaq 0x20(%rsp), %rdi
callq 0x10e1e
leaq 0x39033(%rip), %rsi     # 0x4a5bb
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x11682
leaq 0x3915b(%rip), %rdx     # 0x4a6f9
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xf154
movq 0x20(%r14), %rsi
movq %rsp, %rdi
callq 0x10e1e
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movq %rsp, %rdx
callq 0xf5f1
movb $0x1, %bpl
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0xb8d0
xorl %ebp, %ebp
movq 0x5ba06(%rip), %rsi     # 0x6cff0
movq 0x5b977(%rip), %rdx     # 0x6cf68
movq %rbx, %rdi
callq 0xb970
movq %rax, 0x18(%r14)
movq %rcx, 0x10(%r14)
andq $0x0, 0x20(%r14)
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq 0x80(%rsp), %rdi
callq 0xbb18
jmp 0x1162a
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0xbb18
jmp 0x1163a
movq %rax, %r14
movb $0x1, %bpl
leaq 0x60(%rsp), %rdi
callq 0xbb18
jmp 0x1164c
movq %rax, %r14
movb $0x1, %bpl
leaq 0x40(%rsp), %rdi
callq 0xbb18
jmp 0x1165e
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0xbb18
testb %bpl, %bpl
jne 0x11672
jmp 0x1167a
movq %rax, %r14
movq %rbx, %rdi
callq 0xb430
movq %r14, %rdi
callq 0xb9d0
// File: /workspace/github_cpp_makefile_star2_O2/mburhanpurkar[P]fast_xorshift_plus/./rng_helpers.hpp
// Function: rng_helpers::xorshift_plus::gen_floats(float*)
inline void gen_floats(float *rn)
    {
        for (int i=0; i<8; i+=2)
        {
	    uint64_t x = seeds[i];
	    uint64_t y = seeds[i+1];

	    seeds[i] = y;
	    x ^= (x << 23);
	    seeds[i+1] = x ^ y ^ (x >> 17) ^ (y >> 26);
	    
	    uint64_t tmp = seeds[i+1] + y;
	    uint32_t tmp0 = tmp; // low 32 bits
	    uint32_t tmp1 = tmp >> 32; // high 32
	    
	    rn[i] = float(int32_t(tmp0)) * 4.6566129e-10;
	    rn[i+1] = float(int32_t(tmp1)) * 4.6566129e-10;
	}
    }

// Assembly:
vmovddup 0x572(%rip), %xmm0      # xmm0 = mem[0,0]
movq (%rdi), %rax
xorl %ecx, %ecx
cmpq $0x8, %rcx
jae 0x2b14
movq (%rax,%rcx,8), %rdx
movq 0x8(%rax,%rcx,8), %rdi
movq %rdx, %r8
shlq $0x17, %r8
movq %rdi, %r9
shrq $0x1a, %r9
movq %rdi, (%rax,%rcx,8)
xorq %rdx, %r8
xorq %rdi, %r9
xorq %r8, %r9
shrq $0x11, %r8
xorq %r9, %r8
movq %r8, 0x8(%rax,%rcx,8)
addq %rdi, %r8
vmovq %r8, %xmm1
vcvtdq2ps %xmm1, %xmm1
vcvtps2pd %xmm1, %xmm1
vmulpd %xmm0, %xmm1, %xmm1
vcvtpd2ps %xmm1, %xmm1
vmovlps %xmm1, (%rsi,%rcx,4)
addq $0x2, %rcx
jmp 0x2abb
retq
// File: /workspace/github_cpp_makefile_star2_O2/mburhanpurkar[P]fast_xorshift_plus/./fast_rng.hpp
// Function: fast_rng::vec_xorshift_plus::vec_xorshift_plus()
vec_xorshift_plus()
    {
        if (!is_aligned(&s0,32) || !is_aligned(&s1,32))
	    throw std::runtime_error("Fatal: unaligned vec_xorshift_plus!  See discussion in fast_rng.hpp");
      
        std::random_device rd;
        s0 = _mm256_setr_epi64x(rng_helpers::rd64(rd), rng_helpers::rd64(rd), rng_helpers::rd64(rd), rng_helpers::rd64(rd));
	s1 = _mm256_setr_epi64x(rng_helpers::rd64(rd), rng_helpers::rd64(rd), rng_helpers::rd64(rd), rng_helpers::rd64(rd));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1388, %rsp           # imm = 0x1388
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x2640
movq %r14, %rdi
callq 0x2b15
movq %rsp, %rdi
movq %rax, %r14
callq 0x2b15
movq %rsp, %rdi
movq %rax, %r15
callq 0x2b15
movq %rsp, %rdi
movq %rax, %r12
callq 0x2b15
vmovq %r15, %xmm0
vmovq %r14, %xmm1
vmovq %r12, %xmm2
vpunpcklqdq %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[0]
vmovq %rax, %xmm1
vpunpcklqdq %xmm1, %xmm2, %xmm1 # xmm1 = xmm2[0],xmm1[0]
vmovdqa %xmm0, (%rbx)
vmovdqa %xmm1, 0x10(%rbx)
movq %rsp, %rdi
callq 0x2b15
movq %rsp, %rdi
movq %rax, %r14
callq 0x2b15
movq %rsp, %rdi
movq %rax, %r15
callq 0x2b15
movq %rsp, %rdi
movq %rax, %r12
callq 0x2b15
vmovq %r15, %xmm0
vmovq %r14, %xmm1
vmovq %r12, %xmm2
movq %rsp, %rdi
vpunpcklqdq %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[0]
vmovq %rax, %xmm1
vpunpcklqdq %xmm1, %xmm2, %xmm1 # xmm1 = xmm2[0],xmm1[0]
vmovdqa %xmm0, 0x20(%rbx)
vmovdqa %xmm1, 0x30(%rbx)
callq 0x270a
addq $0x1388, %rsp           # imm = 0x1388
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rsp, %rdi
movq %rax, %rbx
callq 0x270a
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/dumpobj.cpp
// Function: read_sections(std::vector<unsigned char, std::allocator<unsigned char>> const&)
std::vector<section> read_sections(const std::vector<uint8_t> &section_data) {

	std::vector<section> sections;
	auto iter = section_data.begin();
	while (iter != section_data.end()) {

		section s;

		s.number = read_8(iter);
		s.flags = read_8(iter);
		s.size = read_32(iter);
		s.org = read_32(iter);

		if (!(s.flags & SEC_NONAME)) s.name = read_cstring(iter);

		sections.emplace_back(std::move(s));
	}
	return sections;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq (%rsi), %rax
movq %rsp, %r15
movq %rax, (%r15)
leaq 0x18(%rsp), %rbp
leaq 0x38(%rsp), %r12
leaq 0x8(%rsp), %r13
cmpq 0x8(%r14), %rax
je 0x25ef
movq %rbp, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
andw $0x0, 0x28(%rsp)
andq $0x0, 0x2c(%rsp)
movb (%rax), %cl
leaq 0x1(%rax), %rdx
movq %rdx, (%rsp)
movb %cl, 0x28(%rsp)
movb 0x1(%rax), %cl
addq $0x2, %rax
movq %rax, (%rsp)
movb %cl, 0x29(%rsp)
movq %r15, %rdi
callq 0x472d
movl %eax, 0x2c(%rsp)
movq %r15, %rdi
callq 0x472d
movl %eax, 0x30(%rsp)
testb $0x40, 0x29(%rsp)
jne 0x25d3
movq %r12, %rdi
movq %r15, %rsi
callq 0x476b
movq %r13, %rdi
movq %r12, %rsi
callq 0x2220
movq %r12, %rdi
callq 0x20d0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x47c0
movq %r13, %rdi
callq 0x20d0
movq (%rsp), %rax
jmp 0x2553
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2603
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x47fc
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/dumpobj.cpp
// Function: read_symbols(std::vector<unsigned char, std::allocator<unsigned char>> const&)
std::vector<symbol> read_symbols(const std::vector<uint8_t> &symbol_data) {

	std::vector<symbol> symbols;

	auto iter = symbol_data.begin();
	while (iter != symbol_data.end()) {
		symbol s;
		s.type = read_8(iter);
		s.flags = read_8(iter);
		s.section = read_8(iter);
		s.offset = s.type == S_UND ? 0 : read_32(iter);
		s.name = read_cstring(iter);


		symbols.emplace_back(std::move(s));
	}

	return symbols;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq (%rsi), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
leaq 0x20(%rsp), %rbp
leaq 0x38(%rsp), %r12
leaq 0x10(%rsp), %r13
cmpq 0x8(%r14), %rax
je 0x2701
movq %rbp, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
andw $0x0, 0x30(%rsp)
movb $-0x1, 0x32(%rsp)
andl $0x0, 0x34(%rsp)
movb (%rax), %cl
leaq 0x1(%rax), %rdx
movq %rdx, 0x8(%rsp)
movb %cl, 0x30(%rsp)
movb 0x1(%rax), %dl
leaq 0x2(%rax), %rsi
movq %rsi, 0x8(%rsp)
movb %dl, 0x31(%rsp)
movb 0x2(%rax), %dl
addq $0x3, %rax
movq %rax, 0x8(%rsp)
movb %dl, 0x32(%rsp)
testb %cl, %cl
je 0x26c0
movq %r15, %rdi
callq 0x472d
jmp 0x26c2
xorl %eax, %eax
movl %eax, 0x34(%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x476b
movq %r13, %rdi
movq %r12, %rsi
callq 0x2220
movq %r12, %rdi
callq 0x20d0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x481e
movq %r13, %rdi
callq 0x20d0
movq 0x8(%rsp), %rax
jmp 0x2659
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2715
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x485a
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/dumpobj.cpp
// Function: dump(char const*)
void dump(const char *name) {
	Header h;
	int fd;
	ssize_t ok;

	fd = open(name, O_RDONLY | O_BINARY);
	if (fd < 0) err(EX_NOINPUT, "Unable to open %s", name);


	ok = read(fd, &h, sizeof(h));
	if (ok != sizeof(h))
		errx(EX_DATAERR, "%s is not an object file", name);

	le_to_host(h.magic);
	le_to_host(h.version);
	le_to_host(h.filetype);

	if (h.magic != MOD_MAGIC || h.version != 1 || h.filetype > 2)
		errx(EX_DATAERR, "%s is not an object file", name);

	lseek(fd, 0, SEEK_SET);
	if (h.filetype == 2) dump_lib(name, fd);

	// files may contain multiple modules.
	while (dump_obj(name, fd)) /* ... */;

	close(fd);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %esi, %esi
xorl %eax, %eax
callq 0x2160
testl %eax, %eax
js 0x4683
movl %eax, %ebp
leaq 0x8(%rsp), %rsi
pushq $0x7
popq %rdx
movl %eax, %edi
callq 0x2290
cmpq $0x7, %rax
jne 0x466f
cmpl $0x5a44525a, 0x8(%rsp)  # imm = 0x5A44525A
jne 0x466f
cmpw $0x1, 0xc(%rsp)
jne 0x466f
movb 0xe(%rsp), %r14b
cmpb $0x3, %r14b
jae 0x466f
movl %ebp, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2340
cmpb $0x2, %r14b
jne 0x4652
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4359
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2732
testb %al, %al
jne 0x4652
movl %ebp, %edi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x2390
leaq 0x6aa2(%rip), %rsi      # 0xb118
pushq $0x41
popq %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2350
leaq 0x6d3c(%rip), %rsi      # 0xb3c6
pushq $0x42
popq %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/dumpobj.cpp
// Function: main
int main(int argc, char **argv) {

	int c;
	while ((c = getopt(argc, argv, "Sgn")) != -1) {
			switch(c) {
				case 'S': flags.S = true; break;
				case 'g': flags.g = true; break;
				case 'n': flags.n = true; break;
				default: exit(EX_USAGE); break;
			}
	}

	argv += optind;
	argc -= optind;

	if (argc == 0) usage();

	for (int i = 0; i < argc; ++i) {
		dump(argv[i]);
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
leaq 0x6d2c(%rip), %r15      # 0xb3d8
leaq 0xdb4d(%rip), %r12      # 0x12200
leaq 0xdb47(%rip), %r13      # 0x12201
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2060
movq %r12, %rcx
cmpl $0x53, %eax
je 0x46dc
cmpl $0x67, %eax
je 0x46ba
cmpl $0x6e, %eax
jne 0x46e1
movq %r13, %rcx
movb $0x1, (%rcx)
jmp 0x46ba
cmpl $-0x1, %eax
jne 0x4720
movq 0xd8f3(%rip), %rax      # 0x11fe0
movslq (%rax), %rax
subl %eax, %ebx
je 0x4728
leaq (%r14,%rax,8), %r14
xorl %r15d, %r15d
testl %ebx, %ebx
cmovlel %r15d, %ebx
cmpq %r15, %rbx
je 0x4714
movq (%r14,%r15,8), %rdi
callq 0x45e7
incq %r15
jmp 0x4701
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
pushq $0x40
popq %rdi
callq 0x2210
callq 0x2513
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/dumpobj.cpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> read_cstring<__gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>>(__gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>&)
std::string read_cstring(T &iter) {
	std::string s;
	for(;;) {
		uint8_t c = *iter;
		++iter;
		if (!c) break;
		s.push_back(c);
	}
	return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%r14), %rcx
movb (%rcx), %al
incq %rcx
movq %rcx, (%r14)
testb %al, %al
je 0x47a1
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2190
jmp 0x4785
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/dumpobj.cpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> read_pstring<__gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>>(__gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>&)
std::string read_pstring(T &iter) {
	std::string s;
	unsigned  size = *iter;
	++iter;
	s.reserve(size);
	while (size--) {
		uint8_t c = *iter;
		++iter;
		s.push_back(c);
	}
	return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rax
movzbl (%rax), %r15d
incq %rax
movq %rax, (%rsi)
movq %r15, %rsi
callq 0x22c0
incl %r15d
decl %r15d
je 0x4c3f
movq (%r14), %rax
movsbl (%rax), %esi
incq %rax
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x2190
jmp 0x4c24
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x4c4a
movq %rax, %r14
movq %rbx, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::to_x[abi:cxx11](unsigned int, unsigned int, char)
std::string disassembler::to_x(uint32_t x, unsigned bytes, char prefix) {
	std::string s;
	char buffer[16];
	if (prefix) s.push_back(prefix);

	if (x > 0xff && bytes < 4) bytes = 4;
	if (x > 0xffff && bytes < 6) bytes = 6;
	if (x > 0xffffff && bytes < 8) bytes = 8;

	memset(buffer, '0', sizeof(buffer));
	int i = 16;
	while (x) {
		buffer[--i] = "0123456789abcdef"[x & 0x0f];
		x >>= 4;
	}

	s.append(buffer + 16 - bytes, buffer + 16);

	return s;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movl %edx, %r14d
movl %esi, %ebp
movb $0x0, 0x10(%rdi)
testb %cl, %cl
je 0x56ff
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x2190
cmpl $0x5, %r14d
pushq $0x4
popq %rcx
cmovael %r14d, %ecx
cmpl $0x100, %ebp            # imm = 0x100
cmovbl %r14d, %ecx
cmpl $0x7, %ecx
pushq $0x6
popq %rax
cmovael %ecx, %eax
cmpl $0x10000, %ebp          # imm = 0x10000
cmovbl %ecx, %eax
cmpl $0x9, %eax
pushq $0x8
popq %rcx
cmovael %eax, %ecx
movaps 0x5dea(%rip), %xmm0     # 0xb520
leaq 0xf(%rsp), %rdx
movaps %xmm0, -0xf(%rdx)
leaq 0x6582(%rip), %rsi      # 0xbcc8
movl %ebp, %edi
testl %edi, %edi
je 0x5762
movl %edi, %r8d
andl $0xf, %r8d
movb (%r8,%rsi), %r8b
movb %r8b, (%rdx)
shrl $0x4, %edi
decq %rdx
jmp 0x5748
cmpl $0x1000000, %ebp        # imm = 0x1000000
cmovael %ecx, %eax
leaq 0x10(%rsp), %rdx
movq %rdx, %rsi
subq %rax, %rsi
movq %rbx, %rdi
callq 0x6cb8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x578c
movq %rax, %r14
movq %rbx, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::operand_size(unsigned char, bool, bool)
int disassembler::operand_size(uint8_t op, bool m, bool x) {
	unsigned mode = modes[op];
	unsigned size = mode & 0x0f;
	if ((mode & m_I) && x) size++; 
	if ((mode & m_M) && m) size++;
	return size;
}

// Assembly:
movl %edi, %eax
leaq 0x5df7(%rip), %rcx      # 0xb5a0
movl (%rcx,%rax,4), %eax
movl %eax, %ecx
andl $0xf, %ecx
movl %eax, %edi
shrl $0x4, %edi
andl %edx, %edi
addl %ecx, %edi
shrl $0x5, %eax
andl %esi, %eax
addl %edi, %eax
retq