LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x10b18
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x10b0a
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x10b1c
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x10ae0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_expr_rtl_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*)
expression::node::node_t parse_expr_rtl_unary(expression &expr,token_string::iterator &ti,const token_string::iterator &tie,unsigned int min_prec,const tokenlist_entry *match_token) {
    token::token_t repl;
    unsigned int prec;

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

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

    return expression::node::none;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x16580
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x55(%rbp)
jne 0x10b66
jmp 0x10baf
movq -0x18(%rbp), %rdi
callq 0x16600
movq %rax, %rsi
movq -0x30(%rbp), %rdx
leaq -0x34(%rbp), %rdi
callq 0x10ad0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x55(%rbp)
jne 0x10b8d
jmp 0x10baf
movq -0x18(%rbp), %rdi
callq 0x16600
movq %rax, %rdi
movl $0x1, %esi
callq 0x3a50
movl %eax, -0x38(%rbp)
cmpl -0x24(%rbp), %eax
setbe %al
movb %al, -0x55(%rbp)
movb -0x55(%rbp), %al
testb $0x1, %al
jne 0x10bbb
jmp 0x10cb5
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x165c0
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x16600
movq -0x60(%rbp), %rdi
movq %rax, %rsi
movl -0x34(%rbp), %edx
callq 0x10a50
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x16580
testb $0x1, %al
jne 0x10c01
jmp 0x10c65
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x16810
movq %rax, %rdi
addq $0x70, %rdi
movl $0x1, %esi
callq 0x168c0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x38(%rbp), %ecx
callq 0x10cd0
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x16810
movq %rax, %rdi
addq $0x70, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x16950
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10cbd
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
leaq 0x14864(%rip), %rsi     # 0x254e4
callq 0x3530
jmp 0x10c87
movq -0x70(%rbp), %rdi
movq 0x22346(%rip), %rsi     # 0x32fd8
movq 0x22327(%rip), %rdx     # 0x32fc0
callq 0x34b0
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x31f0
jmp 0x10cc7
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x34e0
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x16580
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x49(%rbp)
jne 0x113ea
jmp 0x11430
movq -0x10(%rbp), %rdi
callq 0x16600
movq %rax, %rsi
movq -0x28(%rbp), %rdx
leaq -0x34(%rbp), %rdi
callq 0x10ad0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x49(%rbp)
jne 0x11411
jmp 0x11430
movq -0x10(%rbp), %rdi
callq 0x16600
movq %rax, %rdi
xorl %esi, %esi
callq 0x3a50
movl %eax, -0x38(%rbp)
cmpl -0x1c(%rbp), %eax
setbe %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x1143c
jmp 0x114c6
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x165c0
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x16600
movq -0x60(%rbp), %rdi
movq %rax, %rsi
movl -0x34(%rbp), %edx
callq 0x10a50
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x16810
movq %rax, %rdi
addq $0x70, %rdi
movl $0x1, %esi
callq 0x168c0
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x16810
movq %rax, %rdi
addq $0x70, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x16950
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x113cf
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_expr_subexpr(expression&, __gnu_cxx::__normal_iterator<token*, std::vector<token, std::allocator<token>>>&, __gnu_cxx::__normal_iterator<token*, std::vector<token, std::allocator<token>>> const&)
expression::node::node_t parse_expr_subexpr(expression &expr,token_string::iterator &ti,const token_string::iterator &tie) {
    if (ti != tie && (*ti).tval == token::OPEN_PARENS) {
        ti++;/* step past*/ const expression::node::node_t opnode = parse_expr(expr,ti,tie);

        if (ti == tie)
            throw invalid_argument("missing closing parens");
        if ((*ti).tval != token::CLOSE_PARENS)
            throw invalid_argument("missing closing parens");
        ti++;

        return opnode;
    }

    return expression::node::none;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x16580
testb $0x1, %al
jne 0x116da
jmp 0x117f2
movq -0x18(%rbp), %rdi
callq 0x16600
cmpl $0x20, (%rax)
jne 0x117f2
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x165c0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x10cd0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x16970
testb $0x1, %al
jne 0x11728
jmp 0x1177b
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x13dc5(%rip), %rsi     # 0x25508
callq 0x3530
jmp 0x1174a
movq -0x50(%rbp), %rdi
movq 0x21883(%rip), %rsi     # 0x32fd8
movq 0x21864(%rip), %rdx     # 0x32fc0
callq 0x34b0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x31f0
jmp 0x11804
movq -0x18(%rbp), %rdi
callq 0x16600
cmpl $0x21, (%rax)
je 0x117d9
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0x13d64(%rip), %rsi     # 0x25508
callq 0x3530
jmp 0x117ab
movq -0x58(%rbp), %rdi
movq 0x21822(%rip), %rsi     # 0x32fd8
movq 0x21803(%rip), %rdx     # 0x32fc0
callq 0x34b0
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x31f0
jmp 0x11804
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x165c0
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x117fa
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x34e0
nopl (%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: is_type_token(token::token_t&, token const&)
bool is_type_token(token::token_t &repl,const token &t) {
    switch (t.tval) {
        case token::INT:
        case token::CHAR:
        case token::LONG:
        case token::SHORT:
        case token::CONST:
        case token::SIGNED:
        case token::UNSIGNED:
            repl = t.tval;
            return true;
        case token::AMPERSAND:
            repl = token::ADDRESSOF;
            return true;
        case token::STAR:
            repl = token::DEREFERENCE;
            return true;
        default:
            break;
    };

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl $-0x1e, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x58, %eax
ja 0x11876
movq -0x20(%rbp), %rax
leaq 0x12cb9(%rip), %rcx     # 0x244f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x1187c
movq -0x10(%rbp), %rax
movl $0x16, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x1187c
movq -0x10(%rbp), %rax
movl $0x15, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x1187c
jmp 0x11878
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1201c
movq 0x20fa3(%rip), %rax     # 0x32fb8
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x12048
movq -0x8(%rbp), %rdi
leaq 0x13049(%rip), %rsi     # 0x2507f
movb $0x0, %al
callq 0x33f0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x12023
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x169e0
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x7d10
leaq -0x40(%rbp), %rdi
callq 0x30f0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq %rax, %rcx
leaq 0x134c9(%rip), %rsi     # 0x25555
movb $0x0, %al
callq 0x33f0
leaq -0x40(%rbp), %rdi
callq 0x3598
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x169e0
movq %rax, %rdi
addq $0x70, %rdi
callq 0x16a90
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x12122
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x169e0
movq %rax, %rdi
addq $0x70, %rdi
movq -0x48(%rbp), %rsi
callq 0x16ab0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq (%rax), %rdx
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
callq 0x11ff0
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x120a4
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x12155
movq 0x20e6a(%rip), %rax     # 0x32fb8
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x13404(%rip), %rsi     # 0x25564
movb $0x0, %al
callq 0x33f0
movq -0x10(%rbp), %rax
cmpq $-0x1, 0x18(%rax)
je 0x1218c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
movl $0x1, %ecx
callq 0x11ff0
movq -0x8(%rbp), %rdi
leaq 0x133da(%rip), %rsi     # 0x25571
movb $0x0, %al
callq 0x33f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: pp_if_eval(__gnu_cxx::__normal_iterator<token*, std::vector<token, std::allocator<token>>>&, __gnu_cxx::__normal_iterator<token*, std::vector<token, std::allocator<token>>> const&)
bool pp_if_eval(token_string::iterator &ti,const token_string::iterator &tie) {
    (void)ti;
    (void)tie;

    if (ti == tie)
        throw invalid_argument("macro if condition requires something to evaluate");

    expression expr;
    expr.root = parse_expr(expr,ti,tie);

    if (ppt_only)
        dump_expr(NULL,expr);

    if (ti != tie)
        throw invalid_argument("if condition did not fully parse");

    signed long long v = pp_if_eval(expr,expr.root);
    if (ppt_only)
        fprintf(stderr,"#if eval result %lld\n",v);

    return v != 0ll;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16970
testb $0x1, %al
jne 0x130f6
jmp 0x13149
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x1264f(%rip), %rsi     # 0x25760
callq 0x3530
jmp 0x13118
movq -0x50(%rbp), %rdi
movq 0x1feb5(%rip), %rsi     # 0x32fd8
movq 0x1fe96(%rip), %rdx     # 0x32fc0
callq 0x34b0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31f0
jmp 0x13278
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x16b10
movq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x10cd0
movq %rax, -0x58(%rbp)
jmp 0x13172
movq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x202d7(%rip)     # 0x33458
je 0x131a5
xorl %eax, %eax
movl %eax, %edi
leaq -0x40(%rbp), %rsi
callq 0x12130
jmp 0x13192
jmp 0x131a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x1326f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16580
testb $0x1, %al
jne 0x131b8
jmp 0x1320d
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
leaq 0x125bf(%rip), %rsi     # 0x25792
callq 0x3530
jmp 0x131da
movq -0x68(%rbp), %rdi
movq 0x1fdf3(%rip), %rsi     # 0x32fd8
movq 0x1fdd4(%rip), %rdx     # 0x32fc0
callq 0x34b0
jmp 0x13281
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31f0
jmp 0x1326f
movq -0x28(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x121b0
movq %rax, -0x70(%rbp)
jmp 0x13220
movq -0x70(%rbp), %rax
movq %rax, -0x48(%rbp)
testb $0x1, 0x20229(%rip)     # 0x33458
je 0x1324d
movq 0x1fd80(%rip), %rax     # 0x32fb8
movq (%rax), %rdi
movq -0x48(%rbp), %rdx
leaq 0x1256d(%rip), %rsi     # 0x257b3
movb $0x0, %al
callq 0x33f0
cmpq $0x0, -0x48(%rbp)
setne %al
movb %al, -0x71(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x16b40
movb -0x71(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x16b40
movq -0x18(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: tokenit_next_match_inc(__gnu_cxx::__normal_iterator<token*, std::vector<token, std::allocator<token>>>&, __gnu_cxx::__normal_iterator<token*, std::vector<token, std::allocator<token>>>, token::token_t)
static inline bool tokenit_next_match_inc(token_string::iterator &ti,const token_string::iterator tie,const token::token_t c) {
    if (ti != tie && (*ti).tval == c) {
        ti++;
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x16580
testb $0x1, %al
jne 0x143e6
jmp 0x1440b
movq -0x18(%rbp), %rdi
callq 0x16600
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x1440b
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x165c0
movq %rax, -0x28(%rbp)
movb $0x1, -0x1(%rbp)
jmp 0x1440f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: pp_allow_token_display(std::vector<token, std::allocator<token>> const&)
bool pp_allow_token_display(const token_string &tokens) {
    auto ti = tokens.begin();
    const auto tie = tokens.end();

    if (ti != tie) {
        if ((*ti).tval == token::PREPROC) {
            ti++;

            return false;
        }

        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16210
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16280
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x16240
testb $0x1, %al
jne 0x14459
jmp 0x14482
leaq -0x18(%rbp), %rdi
callq 0x162b0
cmpl $0x2, (%rax)
jne 0x1447c
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x162d0
movq %rax, -0x28(%rbp)
movb $0x0, -0x1(%rbp)
jmp 0x14486
movb $0x1, -0x1(%rbp)
jmp 0x14486
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const& string_storage::get<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(unsigned long, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, unsigned long)
const T& string_storage::get(const stringref_t s,const vector<T> &vec,const stringref_t type) {
    if (stringref_class(s) == type) {
        const stringref_t i = stringref_index(s);
        if (i < vec.size())
            return vec[i];

        throw range_error("get_char() out of range");
    }

    throw invalid_argument("get_char() wrong string type");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x15230
cmpq -0x20(%rbp), %rax
jne 0x15348
movq -0x10(%rbp), %rdi
callq 0x15260
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x161c0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x152f8
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x188c0
addq $0x50, %rsp
popq %rbp
retq
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0x10816(%rip), %rsi     # 0x25b29
callq 0x34c0
jmp 0x1531a
movq -0x48(%rbp), %rdi
movq 0x1dca3(%rip), %rsi     # 0x32fc8
movq 0x1dc74(%rip), %rdx     # 0x32fa0
callq 0x34b0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x31f0
jmp 0x15396
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x107de(%rip), %rsi     # 0x25b41
callq 0x3530
jmp 0x1536a
movq -0x50(%rbp), %rdi
movq 0x1dc63(%rip), %rsi     # 0x32fd8
movq 0x1dc44(%rip), %rdx     # 0x32fc0
callq 0x34b0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x31f0
movq -0x30(%rbp), %rdi
callq 0x34e0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x166e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x1685a
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x167a0
addq $0x40, %rsp
popq %rbp
retq
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0xf1a2(%rip), %rsi      # 0x25a17
callq 0x30d0
jmp 0x1687c
movq -0x38(%rbp), %rdi
movq 0x1c771(%rip), %rsi     # 0x32ff8
movq 0x1c722(%rip), %rdx     # 0x32fb0
callq 0x34b0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31f0
movq -0x18(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: expression::getnode(unsigned long const&) const
inline const node& getnode(const node::node_t &n) const {
            if (n < nodelist.size())
                return nodelist[n];
            else
                throw runtime_error("node out of range");
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x166e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x16a2a
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x18e90
addq $0x40, %rsp
popq %rbp
retq
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0xefd2(%rip), %rsi      # 0x25a17
callq 0x30d0
jmp 0x16a4c
movq -0x38(%rbp), %rdi
movq 0x1c5a1(%rip), %rsi     # 0x32ff8
movq 0x1c552(%rip), %rdx     # 0x32fb0
callq 0x34b0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31f0
movq -0x18(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: FileSourceStack::push()
void push() {
        const size_t np = size_t(stkpos+1);

        if (np < src.size())
            stkpos = np;
        else
            throw overflow_error("FileSourceStack stack overflow");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq 0x18(%rdi), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x1b320
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x16ed7
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x16f27
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0xebd0(%rip), %rsi      # 0x25ac2
callq 0x3070
jmp 0x16ef9
movq -0x38(%rbp), %rdi
movq 0x1c07c(%rip), %rsi     # 0x32f80
movq 0x1c06d(%rip), %rdx     # 0x32f78
callq 0x34b0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31f0
jmp 0x16f2d
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x18(%rax)
jl 0x17252
movq -0x20(%rbp), %rdi
movq 0x18(%rdi), %rsi
callq 0x1bdf0
movq %rax, %rdi
callq 0x4230
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
jmp 0x172a2
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0xe89c(%rip), %rsi      # 0x25b09
callq 0x3580
jmp 0x17274
movq -0x28(%rbp), %rdi
movq 0x1bd29(%rip), %rsi     # 0x32fa8
movq 0x1bd6a(%rip), %rdx     # 0x32ff0
callq 0x34b0
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x31f0
jmp 0x172a8
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: FileSourceStack::alloc(unsigned long)
void alloc(const size_t ns) {
        if (src.empty())
            src.resize(ns);
        else if (src.size() != ns)
            throw runtime_error("FileSourceStack attempt to alloc when already allocated");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x1b250
testb $0x1, %al
jne 0x1b1c3
jmp 0x1b1d2
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b290
jmp 0x1b233
movq -0x28(%rbp), %rdi
callq 0x1b320
cmpq -0x10(%rbp), %rax
je 0x1b231
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0xa874(%rip), %rsi      # 0x25a70
callq 0x30d0
jmp 0x1b203
movq -0x30(%rbp), %rdi
movq 0x17dea(%rip), %rsi     # 0x32ff8
movq 0x17d9b(%rip), %rdx     # 0x32fb0
callq 0x34b0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31f0
jmp 0x1b239
jmp 0x1b233
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ashlall[P]StreamStats/Test/./../SourceCode/BasicStats/BasicStats.cpp
// Function: BasicStats::BasicStats()
BasicStats::BasicStats()
{
  sum = 0;
  squaredsum = 0;
  stream_size = 0;
  min = 0; 
  max = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq $0x0, 0x20(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ashlall[P]StreamStats/Test/./../SourceCode/BasicStats/BasicStats.cpp
// Function: BasicStats::copy(BasicStats const&)
void BasicStats::copy(const BasicStats& other)
{
  sum = other.sum;
  squaredsum = other.squaredsum;
  stream_size = other.stream_size;
  min = other.min;
  max = other.max;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rcx
movsd 0x18(%rcx), %xmm0
movsd %xmm0, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq 0x20(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x20(%rdi)
movsd (%rdi), %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, (%rdi)
movsd -0x10(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
movsd 0x8(%rdi), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rdi)
movsd -0x10(%rbp), %xmm0
callq 0x1350
movq -0x18(%rbp), %rdi
movsd %xmm0, 0x10(%rdi)
movsd -0x10(%rbp), %xmm0
callq 0x13b0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ashlall[P]StreamStats/Test/./../SourceCode/BasicStats/BasicStats.cpp
// Function: BasicStats::if_MIN(double)
double BasicStats::if_MIN(double num)
{
  if (stream_size == 1)
    min = num;
  if (num < min)
    return num;
  else
    return min;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x1, 0x20(%rax)
jne 0x137a
movq -0x20(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x20(%rbp), %rax
movsd -0x18(%rbp), %xmm1
movsd 0x10(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x139a
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x13a8
movq -0x20(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nop
// File: ashlall[P]StreamStats/Test/./../SourceCode/BasicStats/BasicStats.cpp
// Function: BasicStats::if_MAX(double)
double BasicStats::if_MAX(double num)
{
  if(stream_size == 1)
    max = num;
  if (num >= max)
    return num;
  else 
    return max; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x1, 0x20(%rax)
jne 0x13da
movq -0x20(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
movq -0x20(%rbp), %rax
movsd -0x18(%rbp), %xmm0
ucomisd 0x18(%rax), %xmm0
jb 0x13f6
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1404
movq -0x20(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 0x1cf0
callq 0x14f0
callq 0x18f0
callq 0x2000
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)
// File: ncbi[P]amr/./tsv.hpp
// Function: Common_sp::TsvOut& Common_sp::TsvOut::operator<<<char [5]>(char const (&) [5])
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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, (%rax)
je 0x1bbf1
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1bb83
movq 0x10(%rsp), %rcx
movq 0x20(%rcx), %rax
cmpq 0x18(%rcx), %rax
jb 0x1bb83
movb $0x1, 0x1b(%rsp)
movl $0x10, %edi
callq 0xc380
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x18(%rax), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1a420
jmp 0x1bae1
leaq 0x94acb(%rip), %rsi     # 0xb05b3
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x1bfc0
jmp 0x1baf9
movq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xcb30
jmp 0x1bb0a
movq 0x8(%rsp), %rdi
movb $0x0, 0x1b(%rsp)
movq 0xc74d5(%rip), %rsi     # 0xe2ff0
movq 0xc744e(%rip), %rdx     # 0xe2f70
callq 0xcc00
jmp 0x1bc05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x1bb6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x1bb64
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xce38
leaq 0x28(%rsp), %rdi
callq 0xce38
testb $0x1, 0x1b(%rsp)
jne 0x1bb77
jmp 0x1bb81
movq 0x8(%rsp), %rdi
callq 0xc530
jmp 0x1bbfb
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1bba3
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl $0x9, %esi
callq 0xc810
jmp 0x1bbce
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1bbcc
movq 0x10(%rsp), %rax
testb $0x1, 0x28(%rax)
je 0x1bbcc
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl $0x23, %esi
callq 0xc810
jmp 0x1bbce
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x68(%rsp), %rsi
callq 0xc690
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xcc70
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, (%rax)
jne 0x1bdd7
jmp 0x1bfa4
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0xc716a(%rip), %rsi     # 0xe2f50
callq 0xc700
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1be04
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x10(%rcx)
movq 0x20(%rcx), %rax
cmpq 0x18(%rcx), %rax
je 0x1bf97
movb $0x1, 0x1f(%rsp)
movl $0x10, %edi
callq 0xc380
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x18(%rax), %rsi
leaq 0x50(%rsp), %rdi
callq 0x1a420
jmp 0x1be4f
leaq 0x9475d(%rip), %rsi     # 0xb05b3
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x1bfc0
jmp 0x1be67
leaq 0x94883(%rip), %rdx     # 0xb06f1
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x144a0
jmp 0x1be82
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rsi
leaq 0x20(%rsp), %rdi
callq 0x1a420
jmp 0x1be97
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x15b80
jmp 0x1beb3
movq 0x8(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0xcb30
jmp 0x1bec7
movq 0x8(%rsp), %rdi
movb $0x0, 0x1f(%rsp)
movq 0xc7118(%rip), %rsi     # 0xe2ff0
movq 0xc7091(%rip), %rdx     # 0xe2f70
callq 0xcc00
jmp 0x1bfb6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x1bf82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x1bf78
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x1bf6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x1bf61
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x1bf57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0xce38
leaq 0x20(%rsp), %rdi
callq 0xce38
leaq 0x90(%rsp), %rdi
callq 0xce38
leaq 0x70(%rsp), %rdi
callq 0xce38
leaq 0x50(%rsp), %rdi
callq 0xce38
testb $0x1, 0x1f(%rsp)
jne 0x1bf8b
jmp 0x1bf95
movq 0x8(%rsp), %rdi
callq 0xc530
jmp 0x1bfac
movq 0x10(%rsp), %rax
movq $0x0, 0x20(%rax)
addq $0xd8, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0xcc70
nopw %cs:(%rax,%rax)
// File: mburhanpurkar[P]fast_xorshift_plus/example.cpp
// Function: main
int main()
{
    const int ny = 16384;
    const int nx = 1024;
    const int stride = 4096;
    const int niter = 10;
    
    // Comparison of mt19937, xorshift_plus, and vec_xorshift_plus
    float *buf = new float[ny * stride];
    memset(buf, 0, ny * stride * sizeof(float));
    time_mt19937(buf, niter, ny, nx, stride);
    time_xorshift_plus(buf, niter, ny, nx, stride);
    time_vec_xorshift_plus(buf, niter, ny, nx, stride);
}

// Assembly:
subq $0x18, %rsp
movl $0x4000, 0x14(%rsp)     # imm = 0x4000
movl $0x400, 0x10(%rsp)      # imm = 0x400
movl $0x1000, 0xc(%rsp)      # imm = 0x1000
movl $0xa, 0x8(%rsp)
movl $0x10000000, %edi       # imm = 0x10000000
callq 0x2030
movq %rax, (%rsp)
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x10000000, %edx       # imm = 0x10000000
callq 0x20b0
movq (%rsp), %rdi
movl $0xa, %esi
movl $0x4000, %edx           # imm = 0x4000
movl $0x400, %ecx            # imm = 0x400
movl $0x1000, %r8d           # imm = 0x1000
callq 0x2430
movq (%rsp), %rdi
movl $0xa, %esi
movl $0x4000, %edx           # imm = 0x4000
movl $0x400, %ecx            # imm = 0x400
movl $0x1000, %r8d           # imm = 0x1000
callq 0x26f0
movq (%rsp), %rdi
movl $0xa, %esi
movl $0x4000, %edx           # imm = 0x4000
movl $0x400, %ecx            # imm = 0x400
movl $0x1000, %r8d           # imm = 0x1000
callq 0x2940
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mburhanpurkar[P]fast_xorshift_plus/example.cpp
// Function: time_vec_xorshift_plus(float*, int, int, int, int)
static void time_vec_xorshift_plus(float *out, int niter, int ny, int nx, int stride)
{
    assert(nx % 8 == 0);
    fast_rng::vec_xorshift_plus x;

    // Start timing
    struct timeval tv0 = rng_helpers::get_time();

    for (int iter = 0; iter < niter; iter++)
        for (int ifreq = 0; ifreq < ny; ifreq++)
            for (int it = 0; it < nx; it += 8)
	        _mm256_storeu_ps(&out[ifreq*stride + it], x.gen_floats());

    // Stop timing
    struct timeval tv1 = rng_helpers::get_time();
    double dt = rng_helpers::time_diff(tv0, tv1);
    double noutputs = double(niter) * double(ny) * double(nx);
    double ns_per_output = 1.0e9 * dt / noutputs;

    cout << "time_vec_xorshift_plus: ns_per_output = " << ns_per_output << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, 0xb8(%rsp)
movl %esi, 0xb4(%rsp)
movl %edx, 0xb0(%rsp)
movl %ecx, 0xac(%rsp)
movl %r8d, 0xa8(%rsp)
movl 0xac(%rsp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x298a
jmp 0x29a9
leaq 0x26e4(%rip), %rdi      # 0x5075
leaq 0x26e9(%rip), %rsi      # 0x5081
movl $0x16, %edx
leaq 0x2774(%rip), %rcx      # 0x5118
callq 0x20d0
leaq 0x60(%rsp), %rdi
callq 0x4680
callq 0x2c50
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
cmpl 0xb4(%rsp), %eax
jge 0x2a96
movl $0x0, 0x48(%rsp)
movl 0x48(%rsp), %eax
cmpl 0xb0(%rsp), %eax
jge 0x2a84
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
cmpl 0xac(%rsp), %eax
jge 0x2a72
movq 0xb8(%rsp), %rax
movl 0x48(%rsp), %ecx
imull 0xa8(%rsp), %ecx
addl 0x44(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x49e0
movq 0x10(%rsp), %rax
movq %rax, 0xe8(%rsp)
vmovaps %ymm0, 0xc0(%rsp)
vmovaps 0xc0(%rsp), %ymm0
movq 0xe8(%rsp), %rax
vmovups %ymm0, (%rax)
movl 0x44(%rsp), %eax
addl $0x8, %eax
movl %eax, 0x44(%rsp)
jmp 0x29fc
jmp 0x2a74
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x29e3
jmp 0x2a86
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x29ca
vzeroupper
callq 0x2c50
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2d10
vmovsd %xmm0, 0x28(%rsp)
vcvtsi2sdl 0xb4(%rsp), %xmm0, %xmm0
vcvtsi2sdl 0xb0(%rsp), %xmm1, %xmm1
vmulsd %xmm1, %xmm0, %xmm0
vcvtsi2sdl 0xac(%rsp), %xmm1, %xmm1
vmulsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, 0x20(%rsp)
vmovsd 0x2522(%rip), %xmm0     # 0x5010
vmulsd 0x28(%rsp), %xmm0, %xmm0
vdivsd 0x20(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x18(%rsp)
movq 0x54c9(%rip), %rdi      # 0x7fd0
leaq 0x2643(%rip), %rsi      # 0x5151
callq 0x2140
movq %rax, %rdi
vmovsd 0x18(%rsp), %xmm0
callq 0x2230
movq %rax, %rdi
movq 0x548d(%rip), %rsi      # 0x7fb8
callq 0x2160
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: mburhanpurkar[P]fast_xorshift_plus/./rng_helpers.hpp
// Function: rng_helpers::get_time()
inline struct timeval get_time()
{
    struct timeval ret;
    if (gettimeofday(&ret, NULL) < 0)
        throw std::runtime_error("gettimeofday() failed");
    return ret;
}

// Assembly:
subq $0x28, %rsp
leaq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x21c0
cmpl $0x0, %eax
jge 0x2cb9
movl $0x10, %edi
callq 0x2080
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x23dd(%rip), %rsi      # 0x505f
callq 0x2060
jmp 0x2c89
movq (%rsp), %rdi
movq 0x535c(%rip), %rsi      # 0x7ff0
movq 0x532d(%rip), %rdx      # 0x7fc8
callq 0x2200
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
callq 0x20e0
jmp 0x2cc8
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdx
addq $0x28, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x2210
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x44(%rsp)
cmpl $0x8, 0x44(%rsp)
jge 0x39a3
movq 0x18(%rsp), %rdi
movslq 0x44(%rsp), %rsi
callq 0x4660
movq 0x18(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x4660
movq 0x18(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movslq 0x44(%rsp), %rsi
callq 0x4660
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rdi
movq %rcx, (%rax)
movq 0x38(%rsp), %rax
shlq $0x17, %rax
xorq 0x38(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
xorq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
shrq $0x11, %rcx
xorq %rcx, %rax
movq 0x30(%rsp), %rcx
shrq $0x1a, %rcx
xorq %rcx, %rax
movq %rax, 0x10(%rsp)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x4660
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdi
movq %rcx, (%rax)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x4660
movq (%rax), %rax
addq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rax
shrq $0x20, %rax
movl %eax, 0x20(%rsp)
vcvtsi2ssl 0x24(%rsp), %xmm0, %xmm1
vcvtss2sd %xmm1, %xmm0, %xmm0
vmovsd 0x16da(%rip), %xmm1     # 0x5028
vmulsd %xmm1, %xmm0, %xmm1
vcvtsd2ss %xmm1, %xmm0, %xmm0
movq 0x48(%rsp), %rax
movslq 0x44(%rsp), %rcx
vmovss %xmm0, (%rax,%rcx,4)
vcvtsi2ssl 0x20(%rsp), %xmm0, %xmm1
vcvtss2sd %xmm1, %xmm0, %xmm0
vmovsd 0x16b1(%rip), %xmm1     # 0x5028
vmulsd %xmm1, %xmm0, %xmm1
vcvtsd2ss %xmm1, %xmm0, %xmm0
movq 0x48(%rsp), %rax
movl 0x44(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
vmovss %xmm0, (%rax,%rcx,4)
movl 0x44(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x44(%rsp)
jmp 0x3850
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: mburhanpurkar[P]fast_xorshift_plus/./fast_rng.hpp
// Function: fast_rng::vec_xorshift_plus::gen_rand_bits()
inline __m256i gen_rand_bits()
    {
        // x = s0
        __m256i x = s0;
        // y = s1
        __m256i y = s1;

	// s0 = y
        s0 = y;
        // x ^= (x << 23)
        x = _mm256_xor_si256(x, _mm256_slli_epi64(x, 23));
        // s1 = x ^ y ^ (x >> 17) ^ (y >> 26)
        s1 = _mm256_xor_si256(x, y);
        s1 = _mm256_xor_si256(s1, _mm256_srli_epi64(x, 17));
        s1 = _mm256_xor_si256(s1, _mm256_srli_epi64(y, 26));

	return _mm256_add_epi64(y, s1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rax
vmovdqa (%rax), %ymm0
vmovdqa %ymm0, 0x20(%rsp)
vmovdqa 0x20(%rax), %ymm0
vmovdqa %ymm0, (%rsp)
vmovdqa (%rsp), %ymm0
vmovdqa %ymm0, (%rax)
vmovdqa 0x20(%rsp), %ymm1
vmovdqa 0x20(%rsp), %ymm0
vmovdqa %ymm0, 0x180(%rsp)
movl $0x17, 0x17c(%rsp)
vmovdqa 0x180(%rsp), %ymm0
movl 0x17c(%rsp), %ecx
vmovd %ecx, %xmm2
vpsllq %xmm2, %ymm0, %ymm0
vmovdqa %ymm1, 0x140(%rsp)
vmovdqa %ymm0, 0x120(%rsp)
vmovdqa 0x140(%rsp), %ymm0
vpxor 0x120(%rsp), %ymm0, %ymm0
vmovdqa %ymm0, 0x20(%rsp)
vmovdqa 0x20(%rsp), %ymm1
vmovdqa (%rsp), %ymm0
vmovdqa %ymm1, 0x100(%rsp)
vmovdqa %ymm0, 0xe0(%rsp)
vmovdqa 0x100(%rsp), %ymm0
vpxor 0xe0(%rsp), %ymm0, %ymm0
vmovdqa %ymm0, 0x20(%rax)
vmovdqa 0x20(%rax), %ymm1
vmovdqa 0x20(%rsp), %ymm0
vmovdqa %ymm0, 0x200(%rsp)
movl $0x11, 0x1fc(%rsp)
vmovdqa 0x200(%rsp), %ymm0
movl 0x1fc(%rsp), %ecx
vmovd %ecx, %xmm2
vpsrlq %xmm2, %ymm0, %ymm0
vmovdqa %ymm1, 0xc0(%rsp)
vmovdqa %ymm0, 0xa0(%rsp)
vmovdqa 0xc0(%rsp), %ymm0
vpxor 0xa0(%rsp), %ymm0, %ymm0
vmovdqa %ymm0, 0x20(%rax)
vmovdqa 0x20(%rax), %ymm1
vmovdqa (%rsp), %ymm0
vmovdqa %ymm0, 0x1c0(%rsp)
movl $0x1a, 0x1bc(%rsp)
vmovdqa 0x1c0(%rsp), %ymm0
movl 0x1bc(%rsp), %ecx
vmovd %ecx, %xmm2
vpsrlq %xmm2, %ymm0, %ymm0
vmovdqa %ymm1, 0x80(%rsp)
vmovdqa %ymm0, 0x60(%rsp)
vmovdqa 0x80(%rsp), %ymm0
vpxor 0x60(%rsp), %ymm0, %ymm0
vmovdqa %ymm0, 0x20(%rax)
vmovdqa (%rsp), %ymm1
vmovdqa 0x20(%rax), %ymm0
vmovdqa %ymm1, 0x240(%rsp)
vmovdqa %ymm0, 0x220(%rsp)
vmovdqa 0x240(%rsp), %ymm0
vpaddq 0x220(%rsp), %ymm0, %ymm0
movq %rbp, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x7990
movq -0x10(%rbp), %rdi
callq 0x79b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7a20
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x79e0
testb $0x1, %al
jne 0x377d
jmp 0x386d
leaq -0x58(%rbp), %rdi
callq 0x7a50
leaq -0x20(%rbp), %rdi
callq 0x7a90
movb %al, -0x99(%rbp)
jmp 0x3797
movb -0x99(%rbp), %al
movb %al, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7a90
movb %al, -0x9a(%rbp)
jmp 0x37b1
movb -0x9a(%rbp), %al
movb %al, -0x37(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7ac0
movl %eax, -0xa0(%rbp)
jmp 0x37cb
movl -0xa0(%rbp), %eax
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7ac0
movl %eax, -0xa4(%rbp)
jmp 0x37e5
movl -0xa4(%rbp), %eax
movl %eax, -0x30(%rbp)
movzbl -0x37(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x384d
leaq -0x88(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x7b60
jmp 0x380c
leaq -0x58(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x3310
leaq -0x88(%rbp), %rdi
callq 0x3160
jmp 0x384d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x7c80
movq -0x98(%rbp), %rdi
callq 0x7ca0
jmp 0x3893
movq -0x98(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x7c00
jmp 0x385f
leaq -0x58(%rbp), %rdi
callq 0x7c80
jmp 0x375a
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x3883
movq -0x98(%rbp), %rdi
callq 0x7ca0
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3440
nopl (%rax)