LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
leaq 0x80(%rsp), %rdi
movq %r14, %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x3f70
movq %rsp, %rdi
movq %r14, %rsi
callq 0x2200
movq %rbx, %rdi
movl $0x102, %esi            # imm = 0x102
callq 0x3faa
movq 0x8(%rbx), %r14
leaq 0x60(%rsp), %rdi
movq %rsp, %rsi
callq 0x2200
leaq 0x40(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x2200
leaq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq %r14, %rdi
callq 0x4830
leaq 0x40(%rsp), %rdi
callq 0x20c0
leaq 0x60(%rsp), %rdi
callq 0x20c0
cmpw $0x3d, 0x18(%rbx)
jne 0x42dd
pushq $0x3d
popq %rsi
movq %rbx, %rdi
callq 0x3faa
movq %rbx, %rdi
callq 0x4350
movl %eax, %ebp
movq 0x10(%rbx), %rbx
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x2200
movsbl %bpl, %edx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x25c2
leaq 0x20(%rsp), %rdi
callq 0x20c0
movq %rsp, %rdi
callq 0x20c0
leaq 0x80(%rsp), %rdi
callq 0x20c0
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x4321
jmp 0x432f
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x20c0
jmp 0x431c
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x20c0
jmp 0x4332
jmp 0x432a
movq %rax, %rbx
jmp 0x433a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20c0
leaq 0x80(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4396
movl %eax, %ebp
cmpw $0x131, 0x18(%rbx)      # imm = 0x131
jne 0x438c
movq %rbx, %rdi
callq 0x3f70
movq %rbx, %rdi
callq 0x4396
movq 0x10(%rbx), %rdi
movsbl %bpl, %edx
movsbl %al, %ecx
movl $0x131, %esi            # imm = 0x131
callq 0x28fc
jmp 0x435b
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x43dc
movl %eax, %ebp
cmpw $0x130, 0x18(%rbx)      # imm = 0x130
jne 0x43d2
movq %rbx, %rdi
callq 0x3f70
movq %rbx, %rdi
callq 0x43dc
movq 0x10(%rbx), %rdi
movsbl %bpl, %edx
movsbl %al, %ecx
movl $0x130, %esi            # imm = 0x130
callq 0x28fc
jmp 0x43a1
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4428
movl %eax, %ebp
movzwl 0x18(%rbx), %r14d
movl %r14d, %eax
andl $-0x2, %eax
cmpw $0x12e, %ax             # imm = 0x12E
jne 0x4421
movq %rbx, %rdi
callq 0x3f70
movq %rbx, %rdi
callq 0x4428
movq 0x10(%rbx), %rdi
movswl %r14w, %esi
movsbl %bpl, %edx
movsbl %al, %ecx
callq 0x28fc
jmp 0x43e8
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4482
movl %eax, %ebp
movzwl 0x18(%rbx), %r14d
movzwl %r14w, %eax
leal -0x12c(%rax), %ecx
cmpl $0x2, %ecx
jb 0x4454
cmpl $0x3e, %eax
je 0x4454
cmpl $0x3c, %eax
jne 0x447a
movq %rbx, %rdi
callq 0x3f70
movq %rbx, %rdi
callq 0x4482
movq 0x10(%rbx), %rdi
movswl %r14w, %esi
movsbl %bpl, %edx
movsbl %al, %ecx
callq 0x28fc
jmp 0x4434
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x44ce
movl %eax, %ebp
movzwl 0x18(%rbx), %r14d
cmpl $0x2d, %r14d
je 0x44a1
cmpl $0x2b, %r14d
jne 0x44c7
movq %rbx, %rdi
callq 0x3f70
movq %rbx, %rdi
callq 0x44ce
movq 0x10(%rbx), %rdi
movsbl %r14b, %esi
movsbl %bpl, %edx
movsbl %al, %ecx
callq 0x280c
jmp 0x448e
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x451a
movl %eax, %ebp
movzwl 0x18(%rbx), %r14d
cmpl $0x2f, %r14d
je 0x44ed
cmpl $0x2a, %r14d
jne 0x4513
movq %rbx, %rdi
callq 0x3f70
movq %rbx, %rdi
callq 0x451a
movq 0x10(%rbx), %rdi
movsbl %r14b, %esi
movsbl %bpl, %edx
movsbl %al, %ecx
callq 0x280c
jmp 0x44da
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4542
movq %rbx, %rdi
callq 0x3f70
movq %rbx, %rdi
callq 0x451a
movq 0x10(%rbx), %rdi
movsbl %al, %esi
popq %rbx
jmp 0x2768
movq %rbx, %rdi
popq %rbx
jmp 0x454c
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x18(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x28(%rdi), %rax
andl $0x0, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movq %rax, 0x40(%rdi)
andq $0x0, (%rdi)
movups %xmm0, 0x48(%rdi)
andl $0x0, 0x58(%rdi)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b90
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x4c60
movq %rbx, %rdi
callq 0x4bbc
movq %r15, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/protonpopsicle[P]lang/src/compiler/ZoneMgr.cpp
// Function: ZoneMgr::addVar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ZoneMgr::addVar(std::string id, std::string type) {
    varTable::iterator iter = zones[inUse].find(id);
    VarData varData;
    
    if (iter == zones[inUse].end()) {
        if (type == "bool") {
            varData.type = BOOL;
            varData.index = boolCount;
            boolCount++;
        }
        else if (type == "int") {
            varData.type = INT;
            varData.index = intCount;
            intCount++;
        }
        else if (type == "string") {
            varData.type = STRING;
            varData.index = stringCount;
            stringCount++;
        }
        zones[inUse].insert(std::make_pair(id, varData));
    }
    else {
        throw Error("'" + id + "' already declared in this scope");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movslq (%rdi), %rax
imulq $0x30, %rax, %rdi
addq 0x8(%r14), %rdi
callq 0x51f0
movslq (%r14), %rcx
movq 0x8(%r14), %rdx
imulq $0x30, %rcx, %rcx
addq %rdx, %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
jne 0x492a
leaq 0x19a4(%rip), %rsi      # 0x621d
movq %r15, %rdi
callq 0x4bdd
testb %al, %al
je 0x4897
movl 0x50(%r14), %r12d
leal 0x1(%r12), %eax
movl %eax, 0x50(%r14)
xorl %r13d, %r13d
jmp 0x48e4
leaq 0x1991(%rip), %rsi      # 0x622f
movq %r15, %rdi
callq 0x4bdd
testb %al, %al
je 0x48bb
movl 0x54(%r14), %r12d
leal 0x1(%r12), %eax
movl %eax, 0x54(%r14)
pushq $0x1
jmp 0x48dd
leaq 0x1954(%rip), %rsi      # 0x6216
movq %r15, %rdi
callq 0x4bdd
testb %al, %al
je 0x48e1
movl 0x58(%r14), %r12d
leal 0x1(%r12), %eax
movl %eax, 0x58(%r14)
pushq $0x2
popq %r13
jmp 0x48e4
xorl %r13d, %r13d
movslq (%r14), %rax
imulq $0x30, %rax, %r15
addq 0x8(%r14), %r15
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2200
shlq $0x20, %r12
orq %r13, %r12
movq %r12, 0x20(%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x5266
movq %rsp, %rdi
callq 0x20c0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x20d0
movq %rax, %r14
leaq 0x194e(%rip), %rsi      # 0x628a
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x4bea
leaq 0x193e(%rip), %rdx      # 0x628c
leaq 0x28(%rsp), %rdi
movq %rsp, %rsi
callq 0x368d
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x33fc
xorl %ebp, %ebp
leaq 0x543c(%rip), %rsi      # 0x9db0
leaq -0x1c99(%rip), %rdx     # 0x2ce2
movq %r14, %rdi
callq 0x2280
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20c0
jmp 0x4998
movq %rax, %rbx
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x20c0
testb %bpl, %bpl
jne 0x49aa
jmp 0x49bf
movq %rax, %rbx
movq %r14, %rdi
callq 0x2110
jmp 0x49bf
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
movslq (%rdi), %r15
imulq $0x30, %r15, %rdi
incq %r15
decq %r15
je 0x4a1c
leaq -0x30(%rdi), %r12
addq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x51f0
movq 0x8(%rbx), %rcx
addq %r12, %rcx
addq $0x38, %rcx
movq %r12, %rdi
cmpq %rax, %rcx
je 0x49e4
movb 0x40(%rax), %al
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x20d0
movq %rax, %rbx
leaq 0x185c(%rip), %rsi      # 0x628a
movq %rsp, %rdi
movq %r14, %rdx
callq 0x4bea
leaq 0x186d(%rip), %rdx      # 0x62ad
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x368d
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x33fc
xorl %ebp, %ebp
leaq 0x534a(%rip), %rsi      # 0x9db0
leaq -0x1d8b(%rip), %rdx     # 0x2ce2
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x20c0
jmp 0x4a8a
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x20c0
testb %bpl, %bpl
jne 0x4a9c
jmp 0x4aa4
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
movslq (%rdi), %r15
imulq $0x30, %r15, %rdi
incq %r15
decq %r15
je 0x4b00
leaq -0x30(%rdi), %r12
addq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x51f0
movq 0x8(%rbx), %rcx
addq %r12, %rcx
addq $0x38, %rcx
movq %r12, %rdi
cmpq %rax, %rcx
je 0x4ac8
movl 0x44(%rax), %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x20d0
movq %rax, %rbx
leaq 0x1778(%rip), %rsi      # 0x628a
movq %rsp, %rdi
movq %r14, %rdx
callq 0x4bea
leaq 0x1789(%rip), %rdx      # 0x62ad
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x368d
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x33fc
xorl %ebp, %ebp
leaq 0x5266(%rip), %rsi      # 0x9db0
leaq -0x1e6f(%rip), %rdx     # 0x2ce2
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x20c0
jmp 0x4b6e
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x20c0
testb %bpl, %bpl
jne 0x4b80
jmp 0x4b88
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x78, %rsp
leaq -0x50(%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 -0x18(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x8be2(%rip), %rdi      # 0xafe0
leaq -0x28(%rbp), %rsi
callq 0x2050
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x21b0
leaq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2794
leaq -0x48(%rbp), %rdi
callq 0x20b0
leaq -0x80(%rbp), %rdi
callq 0x26a4
leaq -0x28(%rbp), %rdi
callq 0x20b0
leaq -0x80(%rbp), %rdi
callq 0x247a
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20b0
jmp 0x245f
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x20b0
leaq -0x80(%rbp), %rdi
callq 0x247a
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
addq $0x10, %rdi
movq 0x8908(%rip), %r12      # 0xafc8
leaq 0x4940(%rip), %r15      # 0x7007
leaq 0x49be(%rip), %r13      # 0x708c
leaq 0x4934(%rip), %r14      # 0x7009
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x276f
movq %rdi, -0x30(%rbp)
leaq 0x8(%rdi), %rsi
leaq -0x50(%rbp), %rdi
callq 0x3a0c
movl -0x50(%rbp), %esi
movq %r12, %rdi
callq 0x2230
movq %rax, %rdi
leaq 0x48fd(%rip), %rsi      # 0x7004
callq 0x2130
leaq -0x48(%rbp), %rbx
movq (%rbx), %rbx
leaq -0x48(%rbp), %rax
cmpq %rax, %rbx
je 0x2755
movl 0x10(%rbx), %esi
movq %r12, %rdi
callq 0x2230
movq %rax, %rdi
movq %r15, %rsi
callq 0x2130
movl 0x14(%rbx), %esi
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
movq %r13, %rsi
callq 0x2130
movq %rax, %rdi
movq %r14, %rsi
callq 0x2130
jmp 0x2710
movq %r12, %rdi
callq 0x20c0
leaq -0x48(%rbp), %rdi
callq 0x2546
movq -0x30(%rbp), %rdi
jmp 0x26d5
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2780
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x2546
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/guitld[P]Graph-Algorithms/source/Graph.cpp
// Function: Graph::DFS(int)
int Graph::DFS(int u){
     if (adj_lists.find(u) == adj_lists.end()){
          cout << "Vertex not found" << endl;
          return 0;
     }

     // Defining structures for the algorithm
     vector <int> visited;
     stack <int> stack;
     stack.push(u);
     visited.push_back(u);

     while (!stack.empty()){
          // Popping the top of the stack
          int curr_v = stack.top();
          // Printing the path
          cout << curr_v << "->";
          stack.pop();
          // Looping through its neighbors
          for (auto const &neighbor : adj_lists[curr_v]){
               // If the neighbor vertex is not marked as visited, the vertex is pushed to the stack and marked as visited
               if (find(visited.begin(), visited.end(), neighbor.first) == visited.end()){
                    visited.push_back(neighbor.first);
                    stack.push(neighbor.first);
               }
          }    
     }
     cout << endl;
     return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
leaq -0x2c(%rbp), %rax
movl %esi, (%rax)
movq %rdi, -0x58(%rbp)
movq %rax, %rsi
callq 0x4fba
testq %rax, %rax
je 0x31f9
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
andq $0x0, -0x40(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x3a64
leaq -0xa8(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x4b9c
leaq -0x50(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x3aee
leaq -0xa8(%rbp), %r12
leaq -0x50(%rbp), %r14
movq -0x78(%rbp), %rax
cmpq -0x98(%rbp), %rax
je 0x31d6
cmpq -0x70(%rbp), %rax
jne 0x3160
movq -0x60(%rbp), %rax
movq -0x8(%rax), %rax
movl $0x200, %ecx            # imm = 0x200
addq %rcx, %rax
movl -0x4(%rax), %esi
movl %esi, -0x30(%rbp)
movq 0x7e5b(%rip), %rdi      # 0xafc8
callq 0x2230
movq %rax, %rdi
leaq 0x3eb7(%rip), %rsi      # 0x7033
callq 0x2130
movq %r12, %rdi
callq 0x4f54
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4170
movq %rax, %rbx
movq %rax, %r15
movq (%r15), %r15
cmpq %rbx, %r15
je 0x3139
leaq 0x10(%r15), %r13
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %r13, %rdx
callq 0x5043
cmpq -0x48(%rbp), %rax
jne 0x319c
movq %r14, %rdi
movq %r13, %rsi
callq 0x3aee
movq %r12, %rdi
movq %r13, %rsi
callq 0x4b9c
jmp 0x319c
movq 0x7deb(%rip), %rdi      # 0xafc8
callq 0x20c0
leaq -0xa8(%rbp), %rdi
callq 0x3f54
leaq -0x50(%rbp), %rdi
callq 0x4b5e
jmp 0x3214
movq 0x7dc8(%rip), %rdi      # 0xafc8
leaq 0x3e0a(%rip), %rsi      # 0x7011
callq 0x2130
movq %rax, %rdi
callq 0x20c0
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3244
jmp 0x3235
jmp 0x3235
jmp 0x3235
jmp 0x3235
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x3f54
leaq -0x50(%rbp), %rdi
callq 0x4b5e
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O2/guitld[P]Graph-Algorithms/source/Graph.cpp
// Function: Graph::DFS_Util_Connected_Components(int, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&)
void Graph::DFS_Util_Connected_Components(int u, vector <int> &visitedNodes, vector <int> &componentsSize){
     if (adj_lists.find(u) == adj_lists.end()){
          cout << "Vértice não se encontra no grafo" << endl;
     }

     vector <int> visited;
     stack <int> stack;
     stack.push(u);
     visited.push_back(u);

     while (!stack.empty()){
          int curr_v = stack.top();
          stack.pop();

          for (auto const &neighbor : adj_lists[curr_v]){
               if (find(visited.begin(), visited.end(), neighbor.first) == visited.end()){
                    visited.push_back(neighbor.first);
                    stack.push(neighbor.first);
               }
          }    
     }
     componentsSize.push_back(visited.size());
     visitedNodes.insert(visitedNodes.end(), visited.begin(), visited.end());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r14
movq %rdx, %rbx
leaq -0x30(%rbp), %rax
movl %esi, (%rax)
movq %rdi, -0x68(%rbp)
movq %rax, %rsi
callq 0x4fba
testq %rax, %rax
jne 0x32a2
movq 0x7d3a(%rip), %rdi      # 0xafc8
leaq 0x3da1(%rip), %rsi      # 0x7036
callq 0x2130
movq %rax, %rdi
callq 0x20c0
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
andq $0x0, -0x40(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x3a64
movq %r14, -0x60(%rbp)
movq %rbx, -0x58(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4b9c
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3aee
leaq -0xb8(%rbp), %r12
leaq -0x50(%rbp), %r14
movq -0x88(%rbp), %rax
cmpq -0xa8(%rbp), %rax
je 0x336b
cmpq -0x80(%rbp), %rax
jne 0x3310
movq -0x70(%rbp), %rax
movq -0x8(%rax), %rax
movl $0x200, %ecx            # imm = 0x200
addq %rcx, %rax
movl -0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movq %r12, %rdi
callq 0x4f54
movq -0x68(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x4170
movq %rax, %r15
movq %rax, %rbx
movq (%rbx), %rbx
cmpq %r15, %rbx
je 0x32ea
leaq 0x10(%rbx), %r13
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %r13, %rdx
callq 0x5043
cmpq -0x48(%rbp), %rax
jne 0x3331
movq %r14, %rdi
movq %r13, %rsi
callq 0x3aee
movq %r12, %rdi
movq %r13, %rsi
callq 0x4b9c
jmp 0x3331
movq -0x48(%rbp), %rax
subq -0x50(%rbp), %rax
shrq $0x2, %rax
leaq -0x2c(%rbp), %rsi
movl %eax, (%rsi)
movq -0x60(%rbp), %rdi
callq 0x50d0
movq -0x58(%rbp), %rdi
movq 0x8(%rdi), %rsi
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x3b34
leaq -0xb8(%rbp), %rdi
callq 0x3f54
leaq -0x50(%rbp), %rdi
callq 0x4b5e
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x33d1
jmp 0x33d1
movq %rax, %rbx
jmp 0x33e0
jmp 0x33d1
jmp 0x33d1
jmp 0x33d1
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x3f54
leaq -0x50(%rbp), %rdi
callq 0x4b5e
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O2/guitld[P]Graph-Algorithms/source/Graph.cpp
// Function: Graph::connected_components()
void Graph::connected_components(){

     // Defining structures for the algorithm
     vector <int> visitedNodes;
     vector <int> componentsSize;
     int numberOfComponents = 0;

     // Looping through the graph. If the current vertex is not marked as visited, then it belongs to a new component
     for (auto node : adj_lists){
          if (find(visitedNodes.begin(), visitedNodes.end(), node.first) == visitedNodes.end()){
               // Calls a DFS to mark new nodes
               DFS_Util_Connected_Components(node.first, visitedNodes, componentsSize);
               numberOfComponents++;
          }
     }

     // Sorting the components in descending order
     sort(componentsSize.begin(), componentsSize.end(), greater<int>());
     cout << numberOfComponents << endl;
     for (auto elem : componentsSize){
          cout << elem << endl;
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq -0x60(%rbp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
leaq -0x40(%rbp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
leaq 0x10(%rdi), %r13
xorl %ebx, %ebx
leaq -0x78(%rbp), %r14
leaq -0x80(%rbp), %r12
movq (%r13), %r13
testq %r13, %r13
je 0x3479
leaq 0x8(%r13), %rsi
movq %r12, %rdi
callq 0x3a0c
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %r12, %rdx
callq 0x5043
cmpq -0x58(%rbp), %rax
jne 0x346f
movl -0x80(%rbp), %esi
movq %r15, %rdi
leaq -0x60(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x3256
incl %ebx
movq %r14, %rdi
callq 0x2546
jmp 0x342f
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x5397
movq 0x7b3b(%rip), %rdi      # 0xafc8
movl %ebx, %esi
callq 0x2230
movq %rax, %rdi
callq 0x20c0
movq -0x40(%rbp), %r14
movq -0x38(%rbp), %r15
movq 0x7b1d(%rip), %rbx      # 0xafc8
cmpq %r15, %r14
je 0x34c9
movl (%r14), %esi
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x20c0
addq $0x4, %r14
jmp 0x34ab
leaq -0x40(%rbp), %rdi
callq 0x4b5e
leaq -0x60(%rbp), %rdi
callq 0x4b5e
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x34fd
jmp 0x34ee
movq %rax, %rbx
movq %r14, %rdi
callq 0x2546
jmp 0x3500
jmp 0x34fd
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x4b5e
leaq -0x60(%rbp), %rdi
callq 0x4b5e
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, -0x38(%rbp)
movl %edx, -0x2c(%rbp)
decl %edx
movslq %edx, %r12
movq %rsi, -0x40(%rbp)
movq %rsi, %rdi
movq %r12, %rsi
callq 0x3b54
movb $0x1, %r15b
testq %rdx, (%rax)
jne 0x35ae
movq -0x40(%rbp), %rdi
movq %r12, %rsi
callq 0x3b54
orq %rdx, (%rax)
leaq -0x2c(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x4170
movq %rax, %rbx
leaq -0x68(%rbp), %r13
movq %rax, %r12
movq (%r12), %r12
cmpq %rbx, %r12
setne %r15b
je 0x35ae
movq %r13, %rdi
movq -0x40(%rbp), %rsi
callq 0x3b76
movl 0x10(%r12), %edx
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x351a
movl %eax, %r14d
movq %r13, %rdi
callq 0x3bf4
testb %r14b, %r14b
je 0x3574
movl %r15d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x3bf4
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x68, %rsp
movq %rdi, %rbx
movslq 0x18(%rdi), %rsi
leaq -0x2a(%rbp), %rdx
movb $0x0, (%rdx)
leaq -0x60(%rbp), %rdi
leaq -0x29(%rbp), %rcx
callq 0x3c08
movq %rbx, -0x38(%rbp)
addq $0x10, %rbx
leaq -0x88(%rbp), %r15
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x367f
movslq 0x8(%rbx), %rsi
decq %rsi
leaq -0x60(%rbp), %rdi
callq 0x3b54
orq %rdx, (%rax)
leaq 0x10(%rbx), %r13
movq %r13, %r14
movq (%r14), %r14
cmpq %r13, %r14
je 0x3667
movq %r15, %rdi
leaq -0x60(%rbp), %rsi
callq 0x3b76
movl 0x10(%r14), %edx
movq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x351a
movl %eax, %r12d
movq %r15, %rdi
callq 0x3bf4
testb %r12b, %r12b
je 0x3631
jmp 0x367f
movslq 0x8(%rbx), %rsi
decq %rsi
leaq -0x60(%rbp), %rdi
callq 0x3b54
notq %rdx
andq %rdx, (%rax)
jmp 0x360f
testq %rbx, %rbx
setne %bl
leaq -0x60(%rbp), %rdi
callq 0x3bf4
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x36a3
jmp 0x36a3
movq %rax, %rbx
jmp 0x36b7
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x3bf4
leaq -0x60(%rbp), %rdi
callq 0x3bf4
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/guitld[P]Graph-Algorithms/source/Graph.cpp
// Function: Graph::dijkstra(int)
vector<int> Graph::dijkstra(int u){

     // Defining structures for the algorithm
     unordered_map<int, bool> visited;
     priority_queue <pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
     vector<int> dists (this->size(), 0);

     pq.push(pair<int, int> (0, u));
     
     while (!pq.empty()){
          // Popping the top of the priority queue
          pair<int,int> curr_v = pq.top();
          pq.pop();
          // Check whether the node was visited or not
          if (!visited[curr_v.second]){
               // Modifying its distance from 'u' vertex
               dists[curr_v.second - 1] = curr_v.first;
               visited[curr_v.second] = true;
               // Looping through its neighbors
               for (auto const &neighbor : this->adj_lists[curr_v.second])
                    if (!visited[neighbor.first])
                         pq.push(pair<int, int> (curr_v.first + neighbor.second, neighbor.first));
          }
     }
     
     return dists;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, %ebx
leaq -0x70(%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)
movaps %xmm0, -0x60(%rbp)
andq $0x0, -0x50(%rbp)
movq %rsi, -0x68(%rbp)
movslq 0x18(%rsi), %rsi
leaq -0x30(%rbp), %rdx
andl $0x0, (%rdx)
leaq -0x40(%rbp), %rcx
movq %rdi, -0x38(%rbp)
callq 0x3c68
leaq -0x30(%rbp), %rsi
andl $0x0, (%rsi)
movl %ebx, 0x4(%rsi)
leaq -0x60(%rbp), %rdi
callq 0x3cc8
leaq -0x60(%rbp), %r12
leaq -0xa0(%rbp), %r13
leaq -0x40(%rbp), %rbx
movq -0x60(%rbp), %rax
cmpq -0x58(%rbp), %rax
je 0x37dd
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq %r12, %rdi
callq 0x3ce8
movq %r13, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x5de2
cmpb $0x0, (%rax)
jne 0x3744
movl -0x30(%rbp), %eax
movslq -0x2c(%rbp), %rcx
movq -0x38(%rbp), %rdx
movq (%rdx), %rdx
movl %eax, -0x4(%rdx,%rcx,4)
movq %r13, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x5de2
movb $0x1, (%rax)
movq -0x68(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x4170
movq %rax, %r15
movq %rax, %r14
movq (%r14), %r14
cmpq %r15, %r14
je 0x3744
leaq 0x10(%r14), %rsi
movq %r13, %rdi
callq 0x5de2
cmpb $0x0, (%rax)
jne 0x37a6
movl 0x14(%r14), %eax
addl -0x30(%rbp), %eax
movl %eax, -0x40(%rbp)
movl 0x10(%r14), %eax
movl %eax, -0x3c(%rbp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3cc8
jmp 0x37a6
leaq -0x60(%rbp), %rdi
callq 0x4074
leaq -0xa0(%rbp), %rdi
callq 0x40b2
movq -0x38(%rbp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3812
movq %rax, %rbx
jmp 0x381e
jmp 0x3812
jmp 0x3812
jmp 0x3812
movq %rax, %rbx
movq -0x38(%rbp), %rdi
callq 0x4b5e
leaq -0x60(%rbp), %rdi
callq 0x4074
leaq -0xa0(%rbp), %rdi
callq 0x40b2
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x36589(%rip), %r12     # 0x552c8
movq %r12, %rsi
callq 0xf5ee
leaq 0x10(%rbx), %r14
xorps %xmm0, %xmm0
andq $0x0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movq (%r15), %rax
cmpq (%r12), %rax
je 0x1ed77
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19058
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
addq $0x10, %r15
movq %r14, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1caba
movq %rax, %r15
movq %r14, %rdi
callq 0xf032
addq $0x8, %rbx
movq %rbx, %rdi
callq 0xedd8
movq %r15, %rdi
callq 0x7400
// File: /workspace/github_cpp_makefile_star2_O2/eryxcc[P]lois/src/extra.cpp
// Function: lois::declareatom::declareatom(lois::Domain*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
declareatom::declareatom(Domain *d, const std::string& s) {
  vptr v = newvar(d, s);
  at = term(v);
  if(!enable(varlist({v}), ftrue)) 
    throw unsatisfiable_exception();
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x263ea
leaq 0x1b59b(%rip), %rax     # 0x53450
movq %rax, (%rbx)
leaq 0x18(%rbx), %r14
movq %r14, %rdi
callq 0x2931a
leaq 0x18(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x38020
leaq 0x38(%rsp), %r15
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x1283e
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x28e16
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x1846e
leaq 0x10(%rsp), %rdi
callq 0xedd8
leaq 0x40(%rsp), %rdi
callq 0xedd8
leaq 0x8(%rsp), %r14
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0xf5a8
leaq 0x48(%rsp), %rdi
pushq $0x1
popq %rdx
leaq 0x7(%rsp), %rcx
movq %r14, %rsi
callq 0x38136
leaq 0x1d3c6(%rip), %rsi     # 0x55308
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0xee5e
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x38042
movl %eax, %ebp
leaq 0x30(%rsp), %rdi
callq 0xedd8
leaq 0x48(%rsp), %rdi
callq 0x112ca
leaq 0x10(%rsp), %rdi
callq 0xedd8
testb %bpl, %bpl
je 0x37f9b
leaq 0x20(%rsp), %rdi
callq 0xedd8
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x7130
leaq 0x1cdd6(%rip), %rcx     # 0x54d80
movq %rcx, (%rax)
leaq 0x1cd8c(%rip), %rsi     # 0x54d40
movq 0x1d025(%rip), %rdx     # 0x54fe0
movq %rax, %rdi
callq 0x73e0
movq %rax, %r14
jmp 0x37ff8
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0xedd8
leaq 0x48(%rsp), %rdi
callq 0x112ca
jmp 0x37fe4
movq %rax, %r14
leaq 0x10(%rsp), %rdi
jmp 0x37ff3
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0xedd8
leaq 0x20(%rsp), %rdi
callq 0xedd8
jmp 0x38007
movq %rax, %r14
leaq 0x20(%rbx), %rdi
callq 0xedd8
movq %rbx, %rdi
callq 0xed44
movq %r14, %rdi
callq 0x7400
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x10, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r13
callq 0x2606e
leaq 0x1d264(%rip), %rbx     # 0x552c8
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2636c
addq $0x8, %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x12b0e
movq %rbx, %rdi
movq %r13, %rsi
callq 0xf5bc
leaq 0x8(%rsp), %rdi
callq 0xedd8
movq (%r15), %r12
movq 0x8(%r15), %r13
leaq 0x8(%rsp), %r15
cmpq %r13, %r12
je 0x380d2
movq %r14, %rdi
movq %r12, %rsi
callq 0xf5a8
movq (%rbx), %rdi
addq $0x20, %rdi
movq %r14, %rsi
callq 0x1124a
movq %r15, %rdi
callq 0xedd8
addq $0x10, %r12
jmp 0x380a5
leaq 0x1d2f7(%rip), %rax     # 0x553d0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
cmpl $0x1, %eax
je 0x380fb
cmpl $0x2, %eax
sete %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
pushq $0x8
popq %rdi
callq 0x7130
leaq 0x1b746(%rip), %rcx     # 0x53850
movq %rcx, (%rax)
leaq 0x1b6ec(%rip), %rsi     # 0x53800
movq 0x1cec5(%rip), %rdx     # 0x54fe0
movq %rax, %rdi
callq 0x73e0
movq %rax, %rbx
movq %r15, %rdi
callq 0xedd8
movq %rbx, %rdi
callq 0x7400
// File: /workspace/github_cpp_makefile_star2_O2/razor[P]rds-tmc-decoder/tmcdec.c
// Function: load_eventcode
void load_eventcode()
{
    int i;
    for (i=0; i<TMC_EVENT_LIST_LINES; i++) {
        int code = strtol(tmc_events[i][2], NULL, 10);
        if (code != 0) {
            eventmsg[code] = 
            tmc_events[i][1];
//            printf("%d=>%s\n", code, eventmsg[code]);
        } else {
            eventmsg[code] = 0;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq $0x10
popq %r14
leaq 0xfece(%rip), %r15      # 0x36050
pushq $0xa
popq %rbx
leaq 0x1ffa4(%rip), %r12     # 0x46130
cmpq $0xc6f0, %r14           # imm = 0xC6F0
je 0x261c1
movq (%r14,%r15), %rdi
xorl %esi, %esi
movl %ebx, %edx
callq 0x26060
testl %eax, %eax
je 0x261b3
movq -0x8(%r14,%r15), %rcx
cltq
movq %rcx, (%r12,%rax,8)
jmp 0x261bb
andq $0x0, 0x1ff75(%rip)     # 0x46130
addq $0x20, %r14
jmp 0x2618c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/razor[P]rds-tmc-decoder/tmcdec.c
// Function: parsemsg
void parsemsg(const char *msg)
{
    char *endptr = NULL;
    tmcmsg.block1 = strtol(msg, &endptr, 16);
    tmcmsg.block2 = strtol(endptr, &endptr, 16);
    tmcmsg.block3 = strtol(endptr, &endptr, 16);
    tmcmsg.block4 = strtol(endptr, &endptr, 16);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq -0x18(%rbp), %rbx
andq $0x0, (%rbx)
pushq $0x10
popq %r14
movq %rbx, %rsi
movl %r14d, %edx
callq 0x26060
movl %eax, 0x23f3e(%rip)     # 0x4a130
movq (%rbx), %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x26060
movl %eax, 0x23f2e(%rip)     # 0x4a134
movq (%rbx), %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x26060
movl %eax, 0x23f1e(%rip)     # 0x4a138
movq (%rbx), %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x26060
movl %eax, 0x23f0e(%rip)     # 0x4a13c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/razor[P]rds-tmc-decoder/tmcdec.c
// Function: main
int main()
{
    char buf[32];
    load_eventcode();
    while (fgets(buf, 32, stdin) != NULL) {
        int s = strlen(buf);
        *(buf+s-1) = 0;
        parsemsg(buf);
        if ((tmcmsg.block2 & 0xF800) == GROUP_8A && 
            (tmcmsg.block2 & 0x1F) == 0x8) printf("%s\t%s\n", buf, getevent());
        else printf("%s\t-\n", buf);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
callq 0x2616c
movq 0xfd70(%rip), %r13      # 0x35fe0
leaq -0x50(%rbp), %rbx
pushq $0x20
popq %r14
movl $0xf81f, %r15d          # imm = 0xF81F
leaq 0xdaaa(%rip), %r12      # 0x33d2f
movq (%r13), %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x26050
testq %rax, %rax
je 0x262fa
movq %rbx, %rdi
callq 0x26030
cltq
movb $0x0, -0x51(%rbp,%rax)
movq %rbx, %rdi
callq 0x261ca
movl 0x23e7e(%rip), %eax     # 0x4a134
andl %r15d, %eax
cmpl $0x8008, %eax           # imm = 0x8008
jne 0x262eb
movl 0x23e72(%rip), %eax     # 0x4a138
movl $0x7ff, %ecx            # imm = 0x7FF
andl %ecx, %eax
leaq 0x1fe5c(%rip), %rcx     # 0x46130
movq (%rcx,%rax,8), %rdx
leaq 0xda49(%rip), %rdi      # 0x33d28
movq %rbx, %rsi
xorl %eax, %eax
callq 0x26040
jmp 0x26285
movq %r12, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x26040
jmp 0x26285
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %rbx
movl $0xa0, %edi
callq 0x4360
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6f66
pushq $0x1
popq %r15
pushq $0x30
popq %r12
movq 0x68(%rbx), %rax
subq 0x60(%rbx), %rax
cqto
idivq %r12
decq %rax
cmpq %rax, %r15
ja 0x6902
movq %r14, %rdi
movq %r15, %rsi
callq 0xe984
incq %r15
jmp 0x68dd
pushq $0x1
popq %r15
pushq $0x48
popq %r12
movq 0x80(%rbx), %rax
subq 0x78(%rbx), %rax
cqto
idivq %r12
decq %rax
cmpq %rax, %r15
ja 0x6932
movq %r14, %rdi
movq %r15, %rsi
callq 0x6fd2
incq %r15
jmp 0x690a
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x298, %rsp            # imm = 0x298
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x4140
leaq -0x2b8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x6e00
leaq -0x58(%rbp), %rdi
callq 0x4180
movq 0x18(%r14), %r15
addq $0x8, %r14
movq %r14, -0x38(%rbp)
leaq -0x78(%rbp), %r13
movq $0x0, -0x30(%rbp)
cmpq -0x38(%rbp), %r15
je 0x6a74
movq 0x20(%r15), %rcx
movq 0x78(%rbx), %rsi
movq 0x80(%rbx), %rax
subq %rsi, %rax
cqto
pushq $0x48
popq %rdi
idivq %rdi
imulq $0x48, %rcx, %rdx
addq %rsi, %rdx
cmpq %rcx, %rax
movl $0x0, %eax
cmovbeq %rax, %rdx
movq 0x38(%rdx), %r12
testq %r12, %r12
je 0x69fa
leaq -0x2b8(%rbp), %rdi
movq %r12, %rsi
callq 0x6e60
movq -0x30(%rbp), %rax
addq 0x50(%r12), %rax
movq %rax, -0x30(%rbp)
jmp 0x6a64
movq 0x185e7(%rip), %rdi     # 0x1efe8
leaq 0xe7bc(%rip), %rsi      # 0x151c4
callq 0x4340
movq %rax, %r14
movq 0x20(%r15), %rdx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x9c96
movq %r14, %rdi
movq %r13, %rsi
callq 0x42d0
movq %rax, %rdi
leaq 0xf4c9(%rip), %rsi      # 0x15efd
callq 0x4340
movq 0x20(%r15), %rsi
movq %rax, %rdi
callq 0x4240
movq %rax, %rdi
leaq 0xe797(%rip), %rsi      # 0x151e6
callq 0x4340
movq %rax, %rdi
callq 0x41a0
movq %r13, %rdi
callq 0x4180
movq %r15, %rdi
callq 0x43d0
movq %rax, %r15
jmp 0x699c
leaq -0x2b8(%rbp), %rdi
callq 0x78ee
movq -0x30(%rbp), %rax
addq $0x298, %rsp            # imm = 0x298
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x4180
jmp 0x6ac8
movq %rax, %rbx
jmp 0x6ac8
jmp 0x6aab
movq %rax, %rbx
jmp 0x6abc
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x4180
leaq -0x2b8(%rbp), %rdi
callq 0x78ee
movq %rbx, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x3e
popq %rsi
movq %r14, %rdi
callq 0x43f0
leaq 0x8(%r12), %rsi
movq %rax, %rdi
callq 0x42d0
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x43f0
leaq 0x28(%r12), %rsi
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
callq 0x41a0
addq $0x48, %r12
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x44d0
incq 0x28(%rbx)
xorl %r12d, %r12d
leaq -0x68(%rbp), %r13
movq -0x40(%rbp), %rax
movq %rax, %rcx
subq %r12, %rcx
jb 0x6f28
movq 0x238(%rbx), %rdx
leaq (%rdx,%r12), %rsi
incq %rcx
cmpq %rax, %rsi
cmovbeq %rdx, %rcx
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4380
movq %r14, %rdi
movq %r13, %rsi
callq 0x42d0
movq %rax, %rdi
callq 0x41a0
movq %r13, %rdi
callq 0x4180
incq 0x28(%rbx)
addq 0x238(%rbx), %r12
jmp 0x6ed1
incq 0x30(%rbx)
leaq -0x48(%rbp), %rdi
callq 0x4180
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x6f55
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x4180
leaq -0x48(%rbp), %rdi
callq 0x4180
movq %rbx, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
leaq -0x80(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x44d0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7c18
leaq -0x80(%rbp), %rdi
callq 0x4180
leaq 0x38(%rbx), %rdi
movq (%r14), %rsi
pushq $0x10
popq %rdx
callq 0x4050
movq 0x38(%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x58(%rbx,%rax)
jne 0x79db
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x41b0
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
callq 0x44d0
leaq 0xda7f(%rip), %rsi      # 0x15478
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x4140
movb $0x1, %r15b
leaq 0xda7c(%rip), %rcx      # 0x1548c
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0x7c52
xorl %r15d, %r15d
leaq 0x16f63(%rip), %rsi     # 0x1e990
leaq 0x69c(%rip), %rdx       # 0x80d0
movq %rbx, %rdi
callq 0x4620
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x4180
jmp 0x7a50
movq %rax, %r14
movb $0x1, %r15b
leaq -0x60(%rbp), %rdi
callq 0x4180
testb %r15b, %r15b
jne 0x7a63
jmp 0x7a79
movq %rax, %r14
movq %rbx, %rdi
callq 0x4260
jmp 0x7a79
movq %rax, %r14
leaq -0x80(%rbp), %rdi
callq 0x4180
movq %r14, %rdi
callq 0x4660
nop