LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::match(short)
void Parser::match(short tag) {
    if (look.tag == tag) {
        move();
    }
    else {
        throw Error(tag, look.tag);
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
cmpw %bp, 0x18(%rdi)
jne 0x45b1
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4540
movl $0x20, %edi
callq 0x20c0
movq %rax, %rbx
movswl 0x18(%r14), %edx
movswl %bp, %esi
movq %rax, %rdi
callq 0x36f0
leaq 0x67db(%rip), %rsi      # 0xadb0
leaq -0x1644(%rip), %rdx     # 0x2f98
movq %rbx, %rdi
callq 0x2240
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O3/protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::block()
void Parser::block() {
    match('{');
    zoneMgr->saveZone();
    zoneMgr->createZone();
    stmts();
    match('}');
    zoneMgr->loadZone();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x7b, %esi
callq 0x4596
movq 0x8(%rbx), %rdi
callq 0x4ffe
movq 0x8(%rbx), %rdi
callq 0x4fe8
movq %rbx, %rdi
callq 0x463e
movq %rbx, %rdi
movl $0x7d, %esi
callq 0x4596
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x5004
nop
// File: /workspace/github_cpp_makefile_star2_O3/protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::decl()
void Parser::decl() {
    // decl -> basic id
    std::string type = look.lexeme;
    move();
    std::string id = look.lexeme;
    match(ID);
    zoneMgr->addVar(id, type);
    // restDecl -> = bool
    if (look.tag == '=') {
        match('=');
        char rhs = boolean();
        byteCoder->assignVar(id, rhs);
    }
    // restDecl -> e
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x20(%rdi), %rsi
movq 0x28(%rdi), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x3306
movq %rbx, %rdi
callq 0x4540
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x3306
movq %rbx, %rdi
movl $0x102, %esi            # imm = 0x102
callq 0x4596
movq 0x8(%rbx), %r14
leaq 0x98(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x88(%rsp), %rdi
callq 0x3306
leaq 0x78(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x68(%rsp), %rdi
callq 0x3306
leaq 0x88(%rsp), %rsi
leaq 0x68(%rsp), %rdx
movq %r14, %rdi
callq 0x500a
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4946
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2160
movq 0x88(%rsp), %rdi
cmpq %r13, %rdi
je 0x4963
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x2160
cmpw $0x3d, 0x18(%rbx)
jne 0x49cd
movq %rbx, %rdi
movl $0x3d, %esi
callq 0x4596
movq %rbx, %rdi
callq 0x4aa2
movl %eax, %ebp
movq 0x10(%rbx), %rbx
leaq 0x58(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x3306
movsbl %bpl, %edx
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x2724
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x49cd
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2160
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x49e4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x49fb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2160
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x4a6b
movq 0x58(%rsp), %rsi
jmp 0x4a57
jmp 0x4a68
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4a42
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x4a42
movq %rax, %rbx
movq 0x88(%rsp), %rdi
cmpq %r13, %rdi
je 0x4a6b
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x4a6b
jmp 0x4a63
movq %rax, %rbx
jmp 0x4a82
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4a82
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x4a99
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O3/protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::boolean()
char Parser::boolean() {
    char lhs, rhs;
    lhs = join(); // bool -> join restBool
    
    // restBool -> || join restBool
    while (look.tag == OR) {
        move();
        rhs = join();
        lhs = byteCoder->evalBool(OR, lhs, rhs);
    }
    // restBool -> e
    return lhs;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4ae8
movl %eax, %ebp
cmpw $0x131, 0x18(%rbx)      # imm = 0x131
jne 0x4ade
movq %rbx, %rdi
callq 0x4540
movq %rbx, %rdi
callq 0x4ae8
movq 0x10(%rbx), %rdi
movsbl %bpl, %edx
movsbl %al, %ecx
movl $0x131, %esi            # imm = 0x131
callq 0x2b72
jmp 0x4aad
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::join()
char Parser::join() {
    char lhs, rhs;
    lhs = equality(); // join -> equality restJoin
    
    // restJoin -> && equality restJoin
    while (look.tag == AND) {
        move();
        rhs = equality();
        lhs = byteCoder->evalBool(AND, lhs, rhs);
    }
    // restJoin -> e
    return lhs;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4b2e
movl %eax, %ebp
cmpw $0x130, 0x18(%rbx)      # imm = 0x130
jne 0x4b24
movq %rbx, %rdi
callq 0x4540
movq %rbx, %rdi
callq 0x4b2e
movq 0x10(%rbx), %rdi
movsbl %bpl, %edx
movsbl %al, %ecx
movl $0x130, %esi            # imm = 0x130
callq 0x2b72
jmp 0x4af3
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::equality()
char Parser::equality() {
    short oper;
    char lhs, rhs;
    lhs = rel(); // equality -> rel restEquality
    
    // restEquality -> == rel restEquality | != rel restEquality
    while (look.tag == EQ || look.tag == NE) {
        oper = look.tag;
        move();
        rhs = rel();
        lhs = byteCoder->evalBool(oper, lhs, rhs);
    }
    // restEquality -> e
    return lhs;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x4b7c
movl %eax, %ebp
movzwl 0x18(%rbx), %r14d
movl %r14d, %eax
andl $-0x2, %eax
cmpl $0x12e, %eax            # imm = 0x12E
jne 0x4b74
movq %rbx, %rdi
callq 0x4540
movq %rbx, %rdi
callq 0x4b7c
movq 0x10(%rbx), %rdi
movswl %r14w, %esi
movsbl %bpl, %edx
movsbl %al, %ecx
callq 0x2b72
jmp 0x4b3a
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::rel()
char Parser::rel() {
    short oper;
    char lhs, rhs;
    lhs = expr(); // rel -> expr restRel
    
    // restRel -> < expr restRel | > expr restRel | <= expr restRel | >= expr restRel
    while (look.tag == '<' || look.tag == '>' || look.tag == LE || look.tag == GE) {
        oper = look.tag;
        move();
        rhs = expr();
        lhs = byteCoder->evalBool(oper, lhs, rhs);
    }
    // restRel -> e
    return lhs;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x4bd6
movl %eax, %ebp
movzwl 0x18(%rbx), %r14d
movzwl %r14w, %eax
leal -0x12c(%rax), %ecx
cmpl $0x2, %ecx
jb 0x4ba8
cmpl $0x3e, %eax
je 0x4ba8
cmpl $0x3c, %eax
jne 0x4bce
movq %rbx, %rdi
callq 0x4540
movq %rbx, %rdi
callq 0x4bd6
movq 0x10(%rbx), %rdi
movswl %r14w, %esi
movsbl %bpl, %edx
movsbl %al, %ecx
callq 0x2b72
jmp 0x4b88
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::expr()
char Parser::expr() {
    char oper, lhs, rhs;
    lhs = term(); // expr -> term restExpr
    
    // restExpr -> + term restExpr | - term restExpr
    while (look.tag == '+' || look.tag == '-') {
        oper = look.tag;
        move(); 
        rhs = term();
        lhs = byteCoder->evalArith(oper, lhs, rhs);
    }
    // restExpr -> e
    return lhs;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x4c22
movl %eax, %ebp
movzwl 0x18(%rbx), %r14d
cmpl $0x2d, %r14d
je 0x4bf5
cmpl $0x2b, %r14d
jne 0x4c1b
movq %rbx, %rdi
callq 0x4540
movq %rbx, %rdi
callq 0x4c22
movq 0x10(%rbx), %rdi
movsbl %r14b, %esi
movsbl %bpl, %edx
movsbl %al, %ecx
callq 0x2a62
jmp 0x4be2
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::term()
char Parser::term() {
    char oper, lhs, rhs;
    lhs = unary(); // term -> unary restTerm
    
    // restTerm -> * unary restTerm | / unary restTerm
    while (look.tag == '*' || look.tag == '/') {
        oper = look.tag;
        move(); 
        rhs = unary();
        lhs = byteCoder->evalArith(oper, lhs, rhs);
    }
    // restTerm -> e
    return lhs;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x4c6e
movl %eax, %ebp
movzwl 0x18(%rbx), %r14d
cmpl $0x2f, %r14d
je 0x4c41
cmpl $0x2a, %r14d
jne 0x4c67
movq %rbx, %rdi
callq 0x4540
movq %rbx, %rdi
callq 0x4c6e
movq 0x10(%rbx), %rdi
movsbl %r14b, %esi
movsbl %bpl, %edx
movsbl %al, %ecx
callq 0x2a62
jmp 0x4c2e
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::unary()
char Parser::unary() {
    char rhs;
    
    // unary -> - unary
    if (look.tag == '-') {
        move(); 
        rhs = unary();
        return byteCoder->evalUnary(rhs);
    }
    // unary -> factor
    return factor();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpw $0x2d, 0x18(%rdi)
jne 0x4c96
movq %rbx, %rdi
callq 0x4540
movq %rbx, %rdi
callq 0x4c6e
movq 0x10(%rbx), %rdi
movsbl %al, %esi
popq %rbx
jmp 0x299c
movq %rbx, %rdi
popq %rbx
jmp 0x4ca0
nop
// File: /workspace/github_cpp_makefile_star2_O3/protonpopsicle[P]lang/src/compiler/ZoneMgr.cpp
// Function: ZoneMgr::ZoneMgr()
ZoneMgr::ZoneMgr() {
    inUse       = 0;
    saved       = 0;
    boolCount   = 0;
    intCount    = 0;
    stringCount = 0;
    
    zones.push_back(zone);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x8(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x28(%rdi), %rcx
movl %eax, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movq %rcx, 0x38(%rdi)
movq %rcx, 0x40(%rdi)
movq %rax, (%rdi)
movups %xmm0, 0x48(%rdi)
movl %eax, 0x58(%rdi)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5526
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x5622
movq %rbx, %rdi
callq 0x5552
movq %r15, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O3/protonpopsicle[P]lang/src/compiler/ZoneMgr.cpp
// Function: ZoneMgr::getVarType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
char ZoneMgr::getVarType(std::string id) {
    for (int i = inUse; i != 0; i--) {
        varTable::iterator iter = zones[i].find(id);
        if (iter != zones[i].end()) {
            return iter->second.type; // a variable's type
        }
    }
    throw Error("'" + id + "' wasn't declared in this scope");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movslq (%rdi), %r15
testq %r15, %r15
je 0x52a4
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq %r15, %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %r12
addq %r12, %rdi
movq %r14, %rsi
callq 0x5b00
movq 0x8(%rbx), %rdi
leaq (%rdi,%r12), %rcx
addq $0x8, %rcx
cmpq %rax, %rcx
jne 0x52f3
addq $-0x30, %r12
decq %r15
jne 0x527f
movl $0x20, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x1fe8(%rip), %rsi      # 0x72a0
movq %rsp, %rdi
movq %r14, %rdx
callq 0x5599
leaq 0x1ff9(%rip), %rsi      # 0x72c3
movq %rsp, %rdi
callq 0x2270
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x5303
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x5310
movb 0x40(%rax), %al
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x36ac
xorl %ebp, %ebp
leaq 0x5a70(%rip), %rsi      # 0xadb0
leaq -0x23af(%rip), %rdx     # 0x2f98
movq %rbx, %rdi
callq 0x2240
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x5369
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2160
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5384
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2160
testb %bpl, %bpl
jne 0x53ae
jmp 0x53b6
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x53ae
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x53ae
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/protonpopsicle[P]lang/src/compiler/ZoneMgr.cpp
// Function: ZoneMgr::getVarIndex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int ZoneMgr::getVarIndex(std::string id) {
    for (int i = inUse; i != 0; i--) {
        varTable::iterator iter = zones[i].find(id);
        if (iter != zones[i].end()) {
            return iter->second.index; // a variable's index
        }
    }
    throw Error("'" + id + "' wasn't declared in this scope");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movslq (%rdi), %r15
testq %r15, %r15
je 0x540c
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq %r15, %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %r12
addq %r12, %rdi
movq %r14, %rsi
callq 0x5b00
movq 0x8(%rbx), %rdi
leaq (%rdi,%r12), %rcx
addq $0x8, %rcx
cmpq %rax, %rcx
jne 0x545b
addq $-0x30, %r12
decq %r15
jne 0x53e7
movl $0x20, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x1e80(%rip), %rsi      # 0x72a0
movq %rsp, %rdi
movq %r14, %rdx
callq 0x5599
leaq 0x1e91(%rip), %rsi      # 0x72c3
movq %rsp, %rdi
callq 0x2270
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x546b
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x5478
movl 0x44(%rax), %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x36ac
xorl %ebp, %ebp
leaq 0x5908(%rip), %rsi      # 0xadb0
leaq -0x2517(%rip), %rdx     # 0x2f98
movq %rbx, %rdi
callq 0x2240
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x54d1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2160
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x54ec
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2160
testb %bpl, %bpl
jne 0x5516
jmp 0x551e
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5516
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x5516
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/guitld[P]Graph-Algorithms/source/main.cpp
// Function: main
int main(){

     Graph grp;
     string filename;
     getline(cin, filename);

     grp.fromPajek(filename);

     grp.printMap();


     return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
leaq -0x60(%rbp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq 0x7b2a(%rip), %rdi      # 0x9fe0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %edx
movq 0x7b0f(%rip), %rdi      # 0x9fe0
leaq -0x38(%rbp), %rsi
callq 0x2280
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x2672
leaq -0x90(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x29c6
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x251b
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2160
leaq -0x90(%rbp), %rdi
callq 0x286c
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x253c
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2160
leaq -0x90(%rbp), %rdi
callq 0x259c
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x2572
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2160
jmp 0x2572
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x2587
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2160
leaq -0x90(%rbp), %rdi
callq 0x259c
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/guitld[P]Graph-Algorithms/source/Graph.cpp
// Function: Graph::printMap()
void Graph::printMap(){     
     for (auto elem : adj_lists){
          cout << elem.first << ": ";
          for (auto const &i : elem.second)
               cout << i.first << "(" << i.second << ")" << ", ";
          cout << endl;
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x298b
leaq -0x48(%rbp), %rbx
movq 0x773b(%rip), %r14      # 0x9fd0
leaq 0x4797(%rip), %r15      # 0x7033
movl 0x8(%rcx), %eax
movl %eax, -0x50(%rbp)
movq %rcx, -0x30(%rbp)
leaq 0x10(%rcx), %rsi
movq %rbx, %rdi
callq 0x4b00
movl -0x50(%rbp), %esi
movq %r14, %rdi
callq 0x2250
movl $0x2, %edx
movq %rax, %rdi
leaq 0x4762(%rip), %rsi      # 0x702e
callq 0x2180
movq -0x48(%rbp), %r13
cmpq %rbx, %r13
je 0x2936
movl 0x10(%r13), %esi
movq %r14, %rdi
callq 0x2250
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
leaq 0x4739(%rip), %rsi      # 0x7031
callq 0x2180
movl 0x14(%r13), %esi
movq %r12, %rdi
callq 0x2250
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
leaq 0x479b(%rip), %rsi      # 0x70b6
callq 0x2180
movl $0x2, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2180
movq (%r13), %r13
jmp 0x28d5
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x297b
movq (%rdi), %r12
movl $0x18, %esi
callq 0x2160
movq %r12, %rdi
cmpq %rbx, %r12
jne 0x2966
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x289c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x299c
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x29bd
movq (%rdi), %r15
movl $0x18, %esi
callq 0x2160
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x29a8
movq %r14, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/guitld[P]Graph-Algorithms/source/Graph.cpp
// Function: Graph::is_cyclic_util(std::vector<bool, std::allocator<bool>>, int)
bool Graph::is_cyclic_util(vector<bool> visited, int node){

     // If the node is marked as visited, cycle detected
     if (visited[node - 1])
          return true;

     // Marking current node
     visited[node - 1] = true;

     // Looping through neighbors of current vertex
     for (auto &neighbor : this->adj_lists[node]){
          if (is_cyclic_util(visited, neighbor.first))
               return true;
     }

     return false;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, -0x2c(%rbp)
leal -0x1(%rdx), %eax
movslq %eax, %rcx
addl $0x3e, %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
sarl $0x6, %edx
movslq %edx, %rax
shlq $0x3, %rax
movq %rsi, -0x40(%rbp)
addq (%rsi), %rax
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
leaq 0x3f(%rsi), %r8
andq %rcx, %r8
xorl %edx, %edx
cmpq %rsi, %r8
setbe %dl
movl $0x1, %esi
shlq %cl, %rsi
movq %rdi, -0x38(%rbp)
movq -0x8(%rax,%rdx,8), %rdi
movb $0x1, %r13b
btq %rcx, %rdi
jb 0x4270
leaq -0x8(,%rdx,8), %rcx
orq %rsi, %rdi
movq %rdi, (%rax,%rcx)
leaq -0x2c(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x4d1c
movq %rax, %r15
xorl %r14d, %r14d
movq %rax, %r12
movq (%r12), %r12
cmpq %r15, %r12
setne %r13b
je 0x4270
leaq -0x68(%rbp), %rbx
movq %rbx, %rdi
movq -0x40(%rbp), %rsi
callq 0x48aa
movl 0x10(%r12), %edx
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x4184
movl %eax, %ebx
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x426c
movq -0x48(%rbp), %rsi
subq %rdi, %rsi
callq 0x2160
movq %r14, -0x68(%rbp)
movl %r14d, -0x60(%rbp)
movq %r14, -0x58(%rbp)
movl %r14d, -0x50(%rbp)
movq %r14, -0x48(%rbp)
testb %bl, %bl
je 0x4213
movl %r13d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x68(%rbp), %rsi
testq %rsi, %rsi
je 0x4297
leaq -0x48(%rbp), %rdi
callq 0x22a0
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/guitld[P]Graph-Algorithms/source/Graph.cpp
// Function: Graph::is_cyclic()
bool Graph::is_cyclic(){

     // Bool vector to mark nodes as visited
     vector<bool> visited (this->size(), false);

     // Looping through the nodes and use the recursive function to find a cycle or not
     for (auto &node : this->adj_lists){

          visited[node.first - 1] = true;

          for (auto &neighbor : node.second){
               if (is_cyclic_util(visited, neighbor.first))
                    return true;
          }
          visited[node.first - 1] = false;
     }
     return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movslq 0x18(%rdi), %rsi
leaq -0x2a(%rbp), %rdx
movb $0x0, (%rdx)
leaq -0x98(%rbp), %r15
leaq -0x29(%rbp), %rcx
movq %r15, %rdi
callq 0x4948
movq %rbx, -0x68(%rbp)
movq 0x10(%rbx), %r8
movq (%r15), %rdi
testq %r8, %r8
setne %bl
je 0x43fc
movl %ebx, -0x30(%rbp)
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
leaq 0x3f(%r15), %rbx
leaq -0x58(%rbp), %r13
movslq 0x8(%r8), %rcx
decq %rcx
leal 0x3f(%rcx), %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
sarl $0x6, %eax
cltq
movq %rcx, %rdx
andq %rbx, %rdx
xorl %esi, %esi
cmpq %r15, %rdx
setbe %sil
movl $0x1, %edx
shlq %cl, %rdx
leaq (%rdi,%rax,8), %rax
orq %rdx, -0x8(%rax,%rsi,8)
movq %r8, -0x60(%rbp)
leaq 0x10(%r8), %r12
movq %r12, -0x70(%rbp)
movq (%r12), %r12
cmpq -0x70(%rbp), %r12
je 0x43a1
movq %r13, %rdi
leaq -0x98(%rbp), %rsi
callq 0x48aa
movl 0x10(%r12), %edx
movq -0x68(%rbp), %rdi
movq %r13, %r14
movq %r13, %rsi
callq 0x4184
movl %eax, %r13d
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x4397
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2160
xorl %eax, %eax
movq %rax, -0x58(%rbp)
movl %eax, -0x50(%rbp)
movq %rax, -0x48(%rbp)
movl %eax, -0x40(%rbp)
movq %rax, -0x38(%rbp)
testb %r13b, %r13b
movq %r14, %r13
je 0x433e
jmp 0x43f2
movq -0x60(%rbp), %r8
movslq 0x8(%r8), %rcx
decq %rcx
movq -0x98(%rbp), %rdi
leal 0x3f(%rcx), %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
sarl $0x6, %eax
cltq
movq %rcx, %rdx
andq %rbx, %rdx
xorl %esi, %esi
cmpq %r15, %rdx
setbe %sil
movq $-0x2, %rdx
rolq %cl, %rdx
leaq (%rdi,%rax,8), %rax
andq %rdx, -0x8(%rax,%rsi,8)
movq (%r8), %r8
testq %r8, %r8
jne 0x42fe
xorl %ebx, %ebx
jmp 0x4401
movq -0x98(%rbp), %rdi
movl -0x30(%rbp), %ebx
testq %rdi, %rdi
je 0x440d
movq -0x78(%rbp), %rsi
subq %rdi, %rsi
callq 0x2160
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x444f
movq %rax, %rbx
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x444f
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x2160
xorl %eax, %eax
movq %rax, -0x58(%rbp)
movl %eax, -0x50(%rbp)
movq %rax, -0x48(%rbp)
movl %eax, -0x40(%rbp)
movq %rax, -0x38(%rbp)
movq -0x98(%rbp), %rdi
testq %rdi, %rdi
je 0x4467
movq -0x78(%rbp), %rsi
subq %rdi, %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/tests/../include/lois.h
// Function: lois::EIteratorOf<lois::term>::operator++()
void EIteratorOf<T>::operator ++ () { 
  disconnectIterator();
  // if(index >= 0) 
  index++;
  connectIterator();
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1eb1e
incl 0x8(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x1e032
nop
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/tests/../include/lois.h
// Function: lois::lsetof<lois::term>::lsetof(lois::lsetof<lois::term>&&)
lsetof<T>(lsetof<T> &&x) : ain(currentcontext) {
    if(x.ain == currentcontext) {
      swap(elts, x.elts);
      }
    else {
      (*this) |= x;
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x391a1(%rip), %rcx     # 0x632c8
movq (%rcx), %rax
movq %rax, (%rdi)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rdi)
testq %rdx, %rdx
je 0x2a152
movq 0x38e87(%rip), %rdi     # 0x62fc8
cmpb $0x0, (%rdi)
je 0x2a14b
incl 0x8(%rdx)
jmp 0x2a152
lock
incl 0x8(%rdx)
movq (%rcx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
cmpq %rax, (%rsi)
je 0x2a174
leaq 0x10(%rbx), %r15
movq %rbx, %rdi
callq 0x21594
jmp 0x2a190
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rbx)
movq 0x20(%rsi), %rax
movq %rax, 0x20(%rbx)
movups %xmm0, 0x10(%rsi)
movq $0x0, 0x20(%rsi)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x1402a
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2a1af
callq 0x13d46
movq %r14, %rdi
callq 0x7420
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/src/../include/lois.h
// Function: bool lois::ArbCondition::enable<std::vector<std::shared_ptr<lois::Variable>, std::allocator<std::shared_ptr<lois::Variable>>>>(std::vector<std::shared_ptr<lois::Variable>, std::allocator<std::shared_ptr<lois::Variable>>>, lois::rbool)
bool enable(T vars, rbool psi) {
    disable();
    currentcontext = ourcontext = std::make_shared<Context> (currentcontext, psi);
    for(auto v: vars) currentcontext->var.push_back(v);
    int res = solver->solveEnv();
    if(res == 1) throw unsolvable_exception();
    return res == 2;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
callq 0x3587a
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x178f3(%rip), %rbx     # 0x632c8
leaq 0x10(%rsp), %r13
leaq 0xf(%rsp), %rdx
movq %r13, %rsi
movq %rbx, %rcx
movq %r12, %r8
callq 0x35e9e
movq (%r13), %rax
movq 0x8(%r13), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, (%r13)
movq %rax, 0x8(%r15)
leaq 0x10(%r15), %r12
movq 0x10(%r15), %rdi
movq %rcx, 0x10(%r15)
testq %rdi, %rdi
je 0x4ba1b
callq 0x13d46
movq 0x8(%r15), %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movq %r12, %rsi
callq 0x14586
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4ba39
callq 0x13d46
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x4ba9e
leaq 0x10(%rsp), %r14
movq 0x17577(%rip), %r13     # 0x62fc8
movq (%r15), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x4ba77
cmpb $0x0, (%r13)
je 0x4ba73
incl 0x8(%rax)
jmp 0x4ba77
lock
incl 0x8(%rax)
movq (%rbx), %rdi
addq $0x20, %rdi
movq %r14, %rsi
callq 0x16e8e
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4ba95
callq 0x13d46
addq $0x10, %r15
cmpq %r12, %r15
jne 0x4ba51
leaq 0x1792b(%rip), %rax     # 0x633d0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
cmpl $0x1, %eax
je 0x4bac7
cmpl $0x2, %eax
sete %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x8, %edi
callq 0x7140
leaq 0x15d78(%rip), %rcx     # 0x61850
movq %rcx, (%rax)
leaq 0x15d1e(%rip), %rsi     # 0x61800
movq 0x174f7(%rip), %rdx     # 0x62fe0
movq %rax, %rdi
callq 0x73f0
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4bb03
callq 0x13d46
movq %rbx, %rdi
callq 0x7420
nop
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/abawaca.cpp
// Function: init_cluster(ScafDpData const&)
Cluster* init_cluster(const ScafDpData& scaf_db)
{
	Cluster* cluster = new Cluster(scaf_db);
	for(size_t i=1; i<=scaf_db.ndps(); i++)
		*cluster += i;
	for(size_t i=1; i<=scaf_db.nscafs(); i++)
		cluster->add_assigned_scaf(i);

	return cluster;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xa0, %edi
callq 0x53a0
movq %rax, %r14
movq %rbx, (%rax)
addq $0x10, %rax
xorl %ecx, %ecx
movl %ecx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %rax, 0x20(%r14)
movq %rax, 0x28(%r14)
movq %rcx, 0x30(%r14)
leaq 0x68(%r14), %rax
movq %rax, 0x38(%r14)
movq $0x1, 0x40(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r14)
movl $0x3f800000, 0x58(%r14) # imm = 0x3F800000
movups %xmm0, 0x60(%r14)
leaq 0x78(%r14), %rax
movl %ecx, 0x78(%r14)
movq %rcx, 0x80(%r14)
movq %rax, 0x88(%r14)
movq %rax, 0x90(%r14)
movq %rcx, 0x98(%r14)
movq 0x68(%rbx), %rax
subq 0x60(%rbx), %rax
cmpq $0x30, %rax
je 0x8ded
movl $0x1, %r15d
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
movq %r14, %rdi
movq %r15, %rsi
callq 0x121cc
incq %r15
movq 0x68(%rbx), %rax
subq 0x60(%rbx), %rax
sarq $0x4, %rax
imulq %r12, %rax
decq %rax
cmpq %rax, %r15
jbe 0x8dc7
movq 0x80(%rbx), %rax
subq 0x78(%rbx), %rax
cmpq $0x48, %rax
je 0x8e43
movq %r14, %r15
addq $0x70, %r15
movl $0x1, %r13d
movabsq $-0x71c71c71c71c71c7, %r12 # imm = 0x8E38E38E38E38E39
movq %r13, -0x30(%rbp)
movq %r15, %rdi
leaq -0x30(%rbp), %rsi
callq 0xb066
incq %r13
movq 0x80(%rbx), %rax
subq 0x78(%rbx), %rax
sarq $0x3, %rax
imulq %r12, %rax
decq %rax
cmpq %rax, %r13
jbe 0x8e15
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/abawaca.cpp
// Function: get_fasta(std::set<unsigned long, std::less<unsigned long>, std::allocator<unsigned long>> const&, ScafDpData const&, char const*)
size_t get_fasta(const set<size_t>& scafs, const ScafDpData& scaf_db, const char* fasta_out)
{
	size_t total_bps = 0;
	Bio::SeqIOWrite_fasta<Bio::DNASequence>  writer(fasta_out);


	for(auto sit=scafs.begin(); sit!=scafs.end(); sit++) {
		const Bio::DNASequence* seq_obj = scaf_db.get_scaf(*sit)->get_seq_obj();
		if(seq_obj == NULL) {
			cerr << "Warning: could not find scaffold " << scaf_db.scaf_id2name(*sit) << " (" << *sit << ") in fasta file" << endl;
			continue;
		}
		writer.write_seq(*seq_obj);
		total_bps += seq_obj->seq().size();
	}

	return total_bps;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x5160
leaq -0x2a8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x938a
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8ea4
callq 0x5340
movq 0x18(%r14), %r15
addq $0x8, %r14
xorl %r12d, %r12d
cmpq %r14, %r15
je 0x8fd5
movq 0x20(%r15), %rax
movq 0x78(%rbx), %rcx
movq 0x80(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
movabsq $-0x71c71c71c71c71c7, %rsi # imm = 0x8E38E38E38E38E39
imulq %rsi, %rdx
cmpq %rax, %rdx
leaq (%rax,%rax,8), %rax
leaq (%rcx,%rax,8), %rax
movl $0x0, %ecx
cmovbeq %rcx, %rax
movq 0x38(%rax), %r13
testq %r13, %r13
je 0x8f11
leaq -0x2a8(%rbp), %rdi
movq %r13, %rsi
callq 0x940e
addq 0x50(%r13), %r12
jmp 0x8fc1
movl $0x21, %edx
movq 0x190cb(%rip), %rdi     # 0x21fe8
leaq 0x102a0(%rip), %rsi     # 0x191c4
callq 0x5420
movq 0x20(%r15), %rdx
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
callq 0xcd9c
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0x190a0(%rip), %rdi     # 0x21fe8
callq 0x5420
movq %rax, %r13
movl $0x2, %edx
movq %rax, %rdi
leaq 0x10fce(%rip), %rsi     # 0x19f2d
callq 0x5420
movq 0x20(%r15), %rsi
movq %r13, %rdi
callq 0x5240
movq %rax, %r13
movl $0xf, %edx
movq %rax, %rdi
leaq 0x10264(%rip), %rsi     # 0x191e6
callq 0x5420
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x5360
movsbl %al, %esi
movq %r13, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5250
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x8fc1
callq 0x5340
movq %r15, %rdi
callq 0x5430
movq %rax, %r15
cmpq %r14, %rax
jne 0x8eb8
leaq -0x2a8(%rbp), %rdi
callq 0x9e24
movq %r12, %rax
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x903a
callq 0x5340
jmp 0x903a
movq %rax, %rbx
jmp 0x903a
jmp 0x9014
movq %rax, %rbx
jmp 0x902e
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x902e
callq 0x5340
leaq -0x2a8(%rbp), %rdi
callq 0x9e24
movq %rbx, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/SeqIOWrite_fasta.h
// Function: Bio::SeqIOWrite_fasta<Bio::Sequence<Bio::DNAString>>::write_seq(Bio::Sequence<Bio::DNAString> const&)
void SeqIOWrite_fasta<S>::write_seq(const S& seq)
{
	this->m_fp << '>' <<  seq.display_id() << ' ' <<  seq.desc() << endl;
	// A conversion from seq.seq() to string is assumed to exist!
	string	str = string(seq.seq());
	this->m_line_num++;
	for(size_t i=0; i<=str.size(); i+=_line_length) {
		this->m_fp << str.substr(i, (i+_line_length<=str.size())? _line_length : str.size()-i+1) << endl;
		this->m_line_num++;
	}
	this->m_seq_num++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
leaq -0x48(%rbp), %r15
movb $0x3e, (%r15)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x5420
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %rax, %rdi
callq 0x5420
movb $0x20, (%r15)
leaq -0x48(%rbp), %rsi
movl $0x1, %edx
movq %rax, %rdi
callq 0x5420
movq 0x28(%r12), %rsi
movq 0x30(%r12), %rdx
movq %rax, %rdi
callq 0x5420
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x5360
movsbl %al, %esi
movq %r15, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5250
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq 0x48(%r12), %rsi
movq 0x50(%r12), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0xb188
incq 0x28(%rbx)
movq 0x8(%r15), %rdx
movq 0x238(%rbx), %rax
xorl %r12d, %r12d
leaq -0x68(%rbp), %r13
leaq (%rax,%r12), %rsi
movq %rdx, %rcx
subq %r12, %rcx
incq %rcx
cmpq %rdx, %rsi
cmovbeq %rax, %rcx
movq %r13, %rdi
leaq -0x48(%rbp), %rsi
movq %r12, %rdx
callq 0x53c0
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %r14, %rdi
callq 0x5420
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x5360
movsbl %al, %esi
movq %r15, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5250
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x954a
callq 0x5340
incq 0x28(%rbx)
movq 0x238(%rbx), %rax
addq %rax, %r12
movq -0x40(%rbp), %rdx
cmpq %rdx, %r12
jbe 0x94db
incq 0x30(%rbx)
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x957b
callq 0x5340
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x95a4
movq %rax, %rbx
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x95a4
callq 0x5340
leaq -0x38(%rbp), %rax
movq -0x48(%rbp), %rdi
cmpq %rax, %rdi
je 0x95b6
callq 0x5340
movq %rbx, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/SeqIOWrite.h
// Function: Bio::SeqIOWrite<Bio::Sequence<Bio::DNAString>>::open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void SeqIOWrite<S>::open(string file)
{
	this->close();
	this->SeqIO::open(file);
	m_fp.open(file.c_str());

	if(m_fp.fail())
		throw Bad_file(file, "Failed to open file", __PRETTY_FUNCTION__);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
leaq -0x58(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0xb188
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x8(%rbx), %rdi
leaq -0x68(%rbp), %rsi
callq 0x51e0
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x9f42
callq 0x5340
leaq 0x38(%rbx), %rdi
movq (%r14), %rsi
movl $0x10, %edx
callq 0x5060
movq 0x38(%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x58(%rbx,%rax)
jne 0x9f71
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x51b0
movq %rax, %rbx
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0xb188
leaq -0x78(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0xf4d0(%rip), %rsi      # 0x19478
leaq 0xf4dc(%rip), %rdx      # 0x1948b
leaq -0x88(%rbp), %rdi
callq 0xb226
movb $0x1, %r12b
leaq 0xf4c7(%rip), %rcx      # 0x1948c
leaq -0x48(%rbp), %rsi
leaq -0x88(%rbp), %rdx
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0xa2c0
xorl %r12d, %r12d
leaq 0x179a3(%rip), %rsi     # 0x21988
leaq 0xddc(%rip), %rdx       # 0xadc8
movq %rbx, %rdi
callq 0x5660
movq %rax, %r14
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0xa008
callq 0x5340
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xa016
callq 0x5340
testb %r12b, %r12b
jne 0xa033
jmp 0xa04e
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xa033
callq 0x5340
jmp 0xa033
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
jmp 0xa04e
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0xa04e
callq 0x5340
movq %r14, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/SeqIOWrite.h
// Function: Bio::SeqIOWrite<Bio::Sequence<Bio::DNAString>>::restart()
void SeqIOWrite<S>::restart()
{
	SeqIO::restart();

	m_fp.close();
	m_fp.open(this->file_name().c_str());

	if(m_fp.fail())
		throw Bio::Bad_file(this->file_name(), "Failed to re-open file", __PRETTY_FUNCTION__);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq $0x0, 0x30(%rdi)
movq $0x1, 0x28(%rdi)
leaq 0x38(%rdi), %rbx
movq %rbx, %rdi
callq 0x5530
leaq -0x78(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %r15
movq %r15, %rdi
callq 0xb188
movq (%r15), %rsi
movq %rbx, %rdi
movl $0x10, %edx
callq 0x5060
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0xa0ca
callq 0x5340
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
jne 0xa0e7
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x51b0
movq %rax, %rbx
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0xb188
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0xf43e(%rip), %rsi      # 0x1955d
leaq 0xf44d(%rip), %rdx      # 0x19573
leaq -0x68(%rbp), %rdi
callq 0xb226
movb $0x1, %r12b
leaq 0xf43b(%rip), %rcx      # 0x19574
leaq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rdx
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0xa2c0
xorl %r12d, %r12d
leaq 0x17832(%rip), %rsi     # 0x21988
leaq 0xc6b(%rip), %rdx       # 0xadc8
movq %rbx, %rdi
callq 0x5660
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0xa176
callq 0x5340
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xa184
callq 0x5340
testb %r12b, %r12b
jne 0xa1a1
jmp 0xa1bf
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xa1a1
callq 0x5340
jmp 0xa1a1
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
jmp 0xa1bf
movq %rax, %r14
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0xa1bf
callq 0x5340
movq %r14, %rdi
callq 0x56a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/TinyMT-src-1.0.1/tinymt/tinymt32.c
// Function: period_certification(TINYMT32_T*)
static void period_certification(tinymt32_t * random) {
    if ((random->status[0] & TINYMT32_MASK) == 0 &&
	random->status[1] == 0 &&
	random->status[2] == 0 &&
	random->status[3] == 0) {
	random->status[0] = 'T';
	random->status[1] = 'I';
	random->status[2] = 'N';
	random->status[3] = 'Y';
    }
}

// Assembly:
testl $0x7fffffff, (%rdi)     # imm = 0x7FFFFFFF
je 0xba48
retq
cmpl $0x0, 0x4(%rdi)
jne 0xba47
cmpl $0x0, 0x8(%rdi)
jne 0xba47
cmpl $0x0, 0xc(%rdi)
jne 0xba47
pushq %rbp
movq %rsp, %rbp
movaps 0xdd0b(%rip), %xmm0     # 0x19770
movups %xmm0, (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/ScafDpData.cpp
// Function: ScafDpData::dp2scaf(unsigned long) const
size_t ScafDpData::dp2scaf(size_t dp) const
{
	if((dp == 0) || (dp >= dps.size())) {
		char s[2048];
		sprintf(s, "%s (%d): Invalid dp %lu", __FILE__, __LINE__, dp);
		throw invalid_argument(s);
	}
	return dps[dp].get_scaf_id();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq %rsi, %r8
testq %rsi, %rsi
je 0xcc81
movq 0x60(%rdi), %rax
movq 0x68(%rdi), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq %r8, %rdx
jbe 0xcc81
leaq (%r8,%r8,2), %rcx
shlq $0x4, %rcx
movq 0x10(%rax,%rcx), %rax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xcd2a(%rip), %rsi      # 0x199b2
leaq 0xcb01(%rip), %rdx      # 0x19790
leaq -0x810(%rbp), %r14
movq %r14, %rdi
movl $0x7f, %ecx
xorl %eax, %eax
callq 0x5090
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x5730
movq 0x15304(%rip), %rsi     # 0x21fc8
movq 0x152ed(%rip), %rdx     # 0x21fb8
movq %rbx, %rdi
callq 0x5660
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/ScafDpData.cpp
// Function: ScafDpData::ndps(unsigned long) const
size_t ScafDpData::ndps(size_t scaf_id) const
{
	if((scaf_id == 0) || (scaf_id >= scafs.size())) {
		char s[2048];
		sprintf(s, "%s (%d): Invalid scaf_id %lu", __FILE__, __LINE__, scaf_id);
		throw invalid_argument(s);
	}
        return scafs[scaf_id].get_scaf_dps().size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq %rsi, %r8
testq %rsi, %rsi
je 0xcd36
movq 0x78(%rdi), %rax
movq 0x80(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x71c71c71c71c71c7, %rdx # imm = 0x8E38E38E38E38E39
imulq %rcx, %rdx
cmpq %r8, %rdx
jbe 0xcd36
leaq (%r8,%r8,8), %rcx
movq 0x30(%rax,%rcx,8), %rax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xcc8d(%rip), %rsi      # 0x199ca
leaq 0xca4c(%rip), %rdx      # 0x19790
leaq -0x810(%rbp), %r14
movq %r14, %rdi
movl $0x8a, %ecx
xorl %eax, %eax
callq 0x5090
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x5730
movq 0x1524f(%rip), %rsi     # 0x21fc8
movq 0x15238(%rip), %rdx     # 0x21fb8
movq %rbx, %rdi
callq 0x5660
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x56a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/ScafDpData.cpp
// Function: ScafDpData::scaf_id2name[abi:cxx11](unsigned long) const
string ScafDpData::scaf_id2name(size_t scaf_id) const
{
	if((scaf_id == 0) || (scaf_id >= scafs.size())) {
		char s[2048];
		sprintf(s, "%s (%d): Invalid scaf_id %lu", __FILE__, __LINE__, scaf_id);
		throw invalid_argument(s);
	}
        return scafs[scaf_id].get_seq_obj()->display_id();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq %rdx, %r8
testq %rdx, %rdx
je 0xce09
movq 0x78(%rsi), %rax
movq 0x80(%rsi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x71c71c71c71c71c7, %rdx # imm = 0x8E38E38E38E38E39
imulq %rcx, %rdx
cmpq %r8, %rdx
jbe 0xce09
movq %rdi, %rbx
leaq (%r8,%r8,8), %rcx
movq 0x38(%rax,%rcx,8), %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
callq 0xb188
movq %rbx, %rax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xcbba(%rip), %rsi      # 0x199ca
leaq 0xc979(%rip), %rdx      # 0x19790
leaq -0x810(%rbp), %r14
movq %r14, %rdi
movl $0x95, %ecx
xorl %eax, %eax
callq 0x5090
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x5730
movq 0x1517c(%rip), %rsi     # 0x21fc8
movq 0x15165(%rip), %rdx     # 0x21fb8
movq %rbx, %rdi
callq 0x5660
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O3/CK7[P]abawaca/src/SeqIORead.h
// Function: Bio::SeqIORead<Bio::Sequence<Bio::DNAString>>::restart()
void SeqIORead<S>::restart()
{
	SeqIO::restart();

	if(m_fp)
		fclose(m_fp);

	if(!(m_fp = fopen(this->file_name().c_str(), "r")))
		throw Bio::Bad_file(this->file_name(), "Failed to re-open file", __PRETTY_FUNCTION__);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq $0x0, 0x30(%rdi)
movq $0x1, 0x28(%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0xdeaa
callq 0x5390
leaq -0x78(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %r15
movq %r15, %rdi
callq 0xb188
movq (%r15), %rdi
leaq 0xb25a(%rip), %rsi      # 0x19131
callq 0x5450
movq %rax, %rbx
movq %rax, 0x38(%r14)
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xdef0
callq 0x5340
testq %rbx, %rbx
je 0xdf04
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x51b0
movq %rax, %rbx
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0xb188
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0xb621(%rip), %rsi      # 0x1955d
leaq 0xb630(%rip), %rdx      # 0x19573
leaq -0x68(%rbp), %rdi
callq 0xb226
movb $0x1, %r12b
leaq 0xbafe(%rip), %rcx      # 0x19a54
leaq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rdx
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0xa2c0
xorl %r12d, %r12d
leaq 0x13a15(%rip), %rsi     # 0x21988
leaq -0x31b2(%rip), %rdx     # 0xadc8
movq %rbx, %rdi
callq 0x5660
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0xdf93
callq 0x5340
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xdfa1
callq 0x5340
testb %r12b, %r12b
jne 0xdfbe
jmp 0xdfc6
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xdfbe
callq 0x5340
jmp 0xdfbe
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x56a0