LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/RecordManager.cc
// Function: RecordManager::RecordManagerTableCreate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void RecordManager::RecordManagerTableCreate(std::string dbName)
{
    Block firstBlock;
    firstBlock.fileName = dbName;
    firstBlock.offset = 0;
    setInt(firstBlock, BLOCKSIZE - 4, 0);
    bm.BufferManagerWrite(firstBlock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1038, %rsp           # imm = 0x1038
movq %rsi, %r15
movq %rdi, %r14
leaq -0x48(%rbp), %rbx
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
andq $0x0, 0x10(%rax)
leaq -0x1048(%rbp), %rdi
movl $0x1000, %edx           # imm = 0x1000
xorl %esi, %esi
callq 0x3160
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3150
leaq -0x1048(%rbp), %rsi
andq $0x0, 0x1020(%rsi)
andl $0x0, 0xffc(%rsi)
movq (%r14), %rdi
callq 0x7c8a
movq %rbx, %rdi
callq 0x34f8
addq $0x1038, %rsp           # imm = 0x1038
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x34f8
movq %r14, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/RecordManager.cc
// Function: RecordManager::InputRecord(Block&, int, std::vector<element, std::allocator<element>> const&, Table&)
void RecordManager::InputRecord(Block & block, int tuplePos, const std::vector<element> & entry, Table & nt)
{
    int startPos = tuplePos;
    block.data[startPos] = 'Y';
    startPos++;
    int index = 0;
    for (auto ele : entry) {
        assert(nt.attributes[index].type == ele.type);
        switch (ele.type) {
            case 0:
                setInt(block, startPos, ele.i);
                startPos += sizeof(int);
                break;
            case 1:
                setFloat(block, startPos, ele.f);
                startPos += sizeof(float);
                break;
            case 2:
                setString(block, startPos, ele.s);
                startPos += nt.attributes[index].length;//Include +1
                break;
            default:
                break;
        }
        index++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %rbx
movslq %edx, %r15
movq %rsi, -0x30(%rbp)
movb $0x59, (%rsi,%r15)
incl %r15d
movq (%rcx), %rax
movq %rax, -0x38(%rbp)
movq 0x8(%rcx), %r12
xorl %r14d, %r14d
movq -0x38(%rbp), %rax
leaq (%rax,%r14), %rsi
cmpq %r12, %rsi
je 0xef9a
leaq -0x68(%rbp), %rdi
callq 0x5e98
movq 0x28(%rbx), %rax
movl 0x20(%rax,%r14,2), %eax
cmpl -0x40(%rbp), %eax
jne 0xefa9
cmpl $0x2, %eax
leaq -0x88(%rbp), %rdi
je 0xef54
cmpl $0x1, %eax
je 0xef3d
testl %eax, %eax
jne 0xef88
movl -0x68(%rbp), %ecx
movq -0x30(%rbp), %rsi
movl %r15d, %edx
callq 0xeaa8
jmp 0xef4e
movss -0x64(%rbp), %xmm0
movq -0x30(%rbp), %rsi
movl %r15d, %edx
callq 0xeac2
addl $0x4, %r15d
jmp 0xef88
movq %rdi, %r13
leaq -0x60(%rbp), %rsi
callq 0x3380
movslq %r15d, %r15
movq -0x30(%rbp), %rax
leaq (%rax,%r15), %rdi
movq -0x88(%rbp), %rsi
callq 0x3260
movq %r13, %rdi
callq 0x34f8
movq 0x28(%rbx), %rax
addl 0x24(%rax,%r14,2), %r15d
leaq -0x60(%rbp), %rdi
callq 0x34f8
addq $0x30, %r14
jmp 0xeeeb
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x272f(%rip), %rdi      # 0x116df
leaq 0x274e(%rip), %rsi      # 0x11705
leaq 0x2758(%rip), %rcx      # 0x11716
movl $0x88, %edx
callq 0x31a0
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x34f8
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/RecordManager.cc
// Function: RecordManager::RecordManagerGetAllOffsets(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Table&)
std::set<long> RecordManager::RecordManagerGetAllOffsets(std::string dbName, Table & nt)
{
    std::set<long> allOffsets;

    bufferIter pBlock;
    int endPoint;
    long offset = 0;
    do {
        pBlock = bm.BufferManagerRead(dbName, offset);
        Block & block = *pBlock;
        endPoint = getInt(block, BLOCKSIZE - 4);
        allOffsets.insert(offset);
        offset += BLOCKSIZE;
    } while (endPoint == BLOCKSIZE);

    // This one should be the same as the code above.
    /*
    for (int i = 0; i < nt.blockCount; i++) {
        allOffsets.insert(BLOCKSIZE * i);
    }
    */
    //assert(nt.blockCount == allOffsets.size());
    return allOffsets;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq -0x30(%rbp), %rax
andq $0x0, (%rax)
movq %rdx, %r15
movq %rsi, %r12
xorl %edx, %edx
movl $0x1000, %r14d          # imm = 0x1000
movq (%r12), %rdi
movq %r15, %rsi
callq 0x7a04
addq $0x10, %rax
movq %rax, %rsi
movl $0xffc, %edx            # imm = 0xFFC
callq 0xea9c
movl %eax, %r13d
movq %rbx, %rdi
leaq -0x30(%rbp), %rsi
callq 0x72f8
movq -0x30(%rbp), %rdx
addq %r14, %rdx
movq %rdx, -0x30(%rbp)
cmpl $0x1000, %r13d          # imm = 0x1000
je 0xf645
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf699
movq %rax, %r14
movq %rbx, %rdi
callq 0x69f0
movq %r14, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/global.cc
// Function: Table::Table(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<AttrType, std::allocator<AttrType>> const&)
Table::Table (const std::string &name, const std::vector<AttrType> &attributes) {
    this->entrySize = 0;
    this->name = name;
    this->blockCount = 1;
    for (size_t i = 0; i < attributes.size(); ++ i) {
        switch (attributes[i].type) {
            case 0: entrySize += sizeof(int); break;
            case 1: entrySize += sizeof(float); break;
            case 2: entrySize += attributes[i].length; break;
            default: assert(false);
        }
    }
    this->attributes = attributes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %r12
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rdi), %rbx
movb $0x0, 0x18(%rdi)
leaq 0x28(%rdi), %r15
xorps %xmm0, %xmm0
andq $0x0, 0x38(%rdi)
movups %xmm0, 0x28(%rdi)
andl $0x0, (%rdi)
movq %rbx, %rdi
callq 0x3150
movl $0x1, 0x40(%r12)
movq (%r14), %rcx
movq 0x8(%r14), %rax
subq %rcx, %rax
pushq $0x60
popq %rsi
cqto
idivq %rsi
movl (%r12), %edx
addq $0x24, %rcx
xorl %esi, %esi
pushq $0x4
popq %rdi
cmpq %rax, %rsi
jae 0xf838
cmpl $0x2, -0x4(%rcx)
movl %edi, %r8d
jb 0xf828
jne 0xf84c
movl (%rcx), %r8d
addl %r8d, %edx
movl %edx, (%r12)
incq %rsi
addq $0x60, %rcx
jmp 0xf815
movq %r15, %rdi
movq %r14, %rsi
callq 0xfe4c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x192c(%rip), %rdi      # 0x1117f
leaq 0x1f5e(%rip), %rsi      # 0x117b8
leaq 0x1f61(%rip), %rcx      # 0x117c2
pushq $0x14
popq %rdx
callq 0x31a0
movq %rax, %r14
movq %r15, %rdi
callq 0x67e6
movq %rbx, %rdi
callq 0x34f8
movq %r14, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/global.cc
// Function: Table::write()
void Table::write() {
    std::ofstream fout((name).c_str());
    fout << name << std::endl;
    fout << entrySize << std::endl;
    fout << attributes.size() << std::endl;
    fout << blockCount << std::endl;
    for (size_t i = 0; i < attributes.size(); ++ i) {
        fout << attributes[i].name << std::endl;
        fout << attributes[i].type << std::endl;
        fout << attributes[i].length << std::endl;
        fout << attributes[i].unique << std::endl;
        fout << attributes[i].indices.size() << std::endl;
        std::set<std::string> &indices = attributes[i].indices;
        for (auto &x : indices) {
            fout << x << std::endl;
        }
        fout << std::endl;
    }
    fout.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq 0x8(%rdi), %rsi
leaq -0x228(%rbp), %r15
pushq $0x10
popq %rdx
movq %r15, %rdi
callq 0x32d0
movq %r15, %rdi
movq %r14, %rsi
callq 0x3250
movq %rax, %rdi
callq 0x3120
movl (%rbx), %esi
leaq -0x228(%rbp), %rdi
callq 0x3440
movq %rax, %rdi
callq 0x3120
movq 0x30(%rbx), %rax
subq 0x28(%rbx), %rax
pushq $0x60
popq %rcx
cqto
idivq %rcx
leaq -0x228(%rbp), %rdi
movq %rax, %rsi
callq 0x31b0
movq %rax, %rdi
callq 0x3120
movl 0x40(%rbx), %esi
leaq -0x228(%rbp), %rdi
callq 0x3440
movq %rax, %rdi
callq 0x3120
xorl %r13d, %r13d
leaq -0x228(%rbp), %r14
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rax
subq %rsi, %rax
cqto
pushq $0x60
popq %rcx
idivq %rcx
cmpq %rax, %r13
jae 0xfa05
imulq $0x60, %r13, %r15
addq %r15, %rsi
movq %r14, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3120
movq 0x28(%rbx), %rax
movl 0x20(%rax,%r15), %esi
movq %r14, %rdi
callq 0x3440
movq %rax, %rdi
callq 0x3120
movq 0x28(%rbx), %rax
movl 0x24(%rax,%r15), %esi
movq %r14, %rdi
callq 0x3440
movq %rax, %rdi
callq 0x3120
movq 0x28(%rbx), %rax
movzbl 0x28(%rax,%r15), %esi
movq %r14, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x3120
movq 0x28(%rbx), %rax
movq 0x58(%rax,%r15), %rsi
movq %r14, %rdi
callq 0x31b0
movq %rax, %rdi
callq 0x3120
movq 0x28(%rbx), %rax
leaq (%rax,%r15), %r12
addq $0x38, %r12
movq 0x10(%r12), %r15
cmpq %r12, %r15
je 0xf9f5
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3120
movq %r15, %rdi
callq 0x32f0
movq %rax, %r15
jmp 0xf9cf
movq %r14, %rdi
callq 0x3120
incq %r13
jmp 0xf926
leaq -0x228(%rbp), %rdi
callq 0x3390
leaq -0x228(%rbp), %rdi
callq 0x33b0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xfa35
jmp 0xfa35
jmp 0xfa35
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x33b0
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/global.cc
// Function: element::print() const
void element::print() const {
    switch (type) {
        case 0: std::cout << i; return;
        case 1: std::cout << f; return;
        case 2: std::cout << s; return;
        default: assert(false);
    }
}

// Assembly:
movq %rdi, %rsi
movl 0x28(%rdi), %eax
cmpl $0x2, %eax
je 0xfbf7
cmpl $0x1, %eax
je 0xfbe6
testl %eax, %eax
jne 0xfc07
movl (%rsi), %esi
movq 0x93e7(%rip), %rdi      # 0x18fc8
jmp 0x3440
movss 0x4(%rsi), %xmm0
movq 0x93d6(%rip), %rdi      # 0x18fc8
jmp 0x31e0
addq $0x8, %rsi
movq 0x93c6(%rip), %rdi      # 0x18fc8
jmp 0x3250
pushq %rbp
movq %rsp, %rbp
leaq 0x156d(%rip), %rdi      # 0x1117f
leaq 0x1b9f(%rip), %rsi      # 0x117b8
leaq 0x1be3(%rip), %rcx      # 0x11803
pushq $0x47
popq %rdx
callq 0x31a0
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/global.cc
// Function: element::operator<(element const&) const
bool element::operator < (const element &rhs) const {
    assert(type == rhs.type);
    switch (type) {
        case 0: return i < rhs.i;
        case 1: return f < rhs.f;
        case 2: return s < rhs.s;
        default: assert(false);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x28(%rdi), %eax
cmpl 0x28(%rsi), %eax
jne 0xfc67
cmpl $0x2, %eax
je 0xfc59
cmpl $0x1, %eax
je 0xfc4b
testl %eax, %eax
jne 0xfc80
movl (%rdi), %eax
cmpl (%rsi), %eax
setl %al
jmp 0xfc57
movss 0x4(%rsi), %xmm0
ucomiss 0x4(%rdi), %xmm0
seta %al
popq %rbp
retq
addq $0x8, %rdi
addq $0x8, %rsi
popq %rbp
jmp 0x63b4
leaq 0x1bb1(%rip), %rdi      # 0x1181f
leaq 0x1b43(%rip), %rsi      # 0x117b8
leaq 0x1bb4(%rip), %rcx      # 0x11830
pushq $0x4c
jmp 0xfc97
leaq 0x14f8(%rip), %rdi      # 0x1117f
leaq 0x1b2a(%rip), %rsi      # 0x117b8
leaq 0x1b9b(%rip), %rcx      # 0x11830
pushq $0x51
popq %rdx
callq 0x31a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/global.cc
// Function: element::operator==(element const&) const
bool element::operator == (const element &rhs) const {
    assert(type == rhs.type);
    switch (type) {
        case 0: return i == rhs.i;
        case 1: return fabs(f - rhs.f) < 1e-8;
        case 2: return s == rhs.s;
        default: assert(false);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x28(%rdi), %eax
cmpl 0x28(%rsi), %eax
jne 0xfcf5
cmpl $0x2, %eax
je 0xfce7
cmpl $0x1, %eax
je 0xfcc1
testl %eax, %eax
jne 0xfd0e
movl (%rdi), %eax
cmpl (%rsi), %eax
sete %al
jmp 0xfce5
movss 0x4(%rdi), %xmm0
subss 0x4(%rsi), %xmm0
andps 0x1ace(%rip), %xmm0     # 0x117a0
cvtss2sd %xmm0, %xmm0
movsd 0x1ad2(%rip), %xmm1     # 0x117b0
ucomisd %xmm0, %xmm1
seta %al
popq %rbp
retq
addq $0x8, %rdi
addq $0x8, %rsi
popq %rbp
jmp 0x5db5
leaq 0x1b23(%rip), %rdi      # 0x1181f
leaq 0x1ab5(%rip), %rsi      # 0x117b8
leaq 0x1b55(%rip), %rcx      # 0x1185f
pushq $0x56
jmp 0xfd25
leaq 0x146a(%rip), %rdi      # 0x1117f
leaq 0x1a9c(%rip), %rsi      # 0x117b8
leaq 0x1b3c(%rip), %rcx      # 0x1185f
pushq $0x5b
popq %rdx
callq 0x31a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/main.cc
// Function: main
int main() {
    A *ui = new A;
    ui->run();
    delete ui;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
pushq $0x1
popq %rdi
callq 0x32a0
movq %rax, %rbx
movq %rax, %rdi
callq 0x104ba
movq %rbx, %rdi
callq 0x3270
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/zimpha[P]MiniSQL/main.cc
// Function: A::run()
void run() {
        std::string buf;
        Interpreter ip;
        do {
            std::cout << ">> ";
            std::getline(std::cin, buf);
            bool flag = ip.process(buf);
            if (flag) break;
        } while (1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x108(%rbp), %rdi
callq 0x38ec
movq 0x8ae7(%rip), %r15      # 0x18fd8
leaq -0x48(%rbp), %r12
leaq -0x68(%rbp), %r13
leaq -0x108(%rbp), %rbx
movq 0x8ac1(%rip), %rdi      # 0x18fc8
leaq 0x1381(%rip), %rsi      # 0x1188f
callq 0x3280
movq %r15, %rdi
movq %r12, %rsi
callq 0x3070
movq %r13, %rdi
movq %r12, %rsi
callq 0x3380
movq %rbx, %rdi
movq %r13, %rsi
callq 0xc984
movl %eax, %r14d
movq %r13, %rdi
callq 0x34f8
testb %r14b, %r14b
je 0x10500
leaq -0x108(%rbp), %rdi
callq 0x105a0
leaq -0x48(%rbp), %rdi
callq 0x34f8
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x1058f
jmp 0x10580
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x34f8
jmp 0x10583
movq %rax, %rbx
leaq -0x108(%rbp), %rdi
callq 0x105a0
leaq -0x48(%rbp), %rdi
callq 0x34f8
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::writeGraph(std::ostream&, int)
void Graph::writeGraph(ostream& out,int j) {
	cout << "Write graph size = " << graph.size() << endl;
	out << "graph_for_greach" << endl;
	out << vl.size() << endl;

	GRA::iterator git;
	EdgeList el;
	EdgeList::iterator eit;
	VertexList::iterator vit;
	int i = 0;
	for (i = 0; i < vl.size(); i++) {
		out << i << ": ";
                if(j==1)        
                    el = graph[i].outList;
                else
                    el = graph[i].inList;
		for (eit = el.begin(); eit != el.end(); eit++)
			out << (*eit) << " ";
		out << "#" << endl;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10637(%rip), %rdi     # 0x14fd8
leaq 0x9a5c(%rip), %rsi      # 0xe404
callq 0x3270
movq %rax, %rdi
movq 0x50(%r15), %rax
subq 0x48(%r15), %rax
pushq $0x30
popq %rcx
cqto
idivq %rcx
movq %rax, %rsi
callq 0x31d0
movq %rax, %rdi
callq 0x3140
leaq 0x99f6(%rip), %rsi      # 0xe3cd
movq %r14, %rdi
callq 0x3270
movq %rax, %rdi
callq 0x3140
movq 0x38(%r15), %rsi
subq 0x30(%r15), %rsi
sarq $0x4, %rsi
movq %r14, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x3140
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
xorl %r13d, %r13d
leaq 0x9b20(%rip), %rbp      # 0xe53b
movq 0x38(%r15), %rax
subq 0x30(%r15), %rax
sarq $0x4, %rax
cmpq %r13, %rax
jbe 0x4ab1
movq %r14, %rdi
movl %r13d, %esi
callq 0x3420
movq %rax, %rdi
leaq 0x995b(%rip), %rsi      # 0xe3a0
callq 0x3270
movq 0x48(%r15), %rax
imulq $0x30, %r13, %rcx
leaq (%rax,%rcx), %rdx
cmpl $0x1, %ebx
leaq 0x18(%rax,%rcx), %rsi
cmovneq %rdx, %rsi
movq %rsp, %rdi
callq 0x98ce
movq (%rsp), %r12
cmpq 0x8(%rsp), %r12
je 0x4a92
movl (%r12), %esi
movq %r14, %rdi
callq 0x3420
movq %rax, %rdi
movq %rbp, %rsi
callq 0x3270
addq $0x4, %r12
jmp 0x4a6e
movq %r14, %rdi
leaq 0x9ab3(%rip), %rsi      # 0xe54f
callq 0x3270
movq %rax, %rdi
callq 0x3140
incq %r13
jmp 0x4a1b
movq %rsp, %rdi
callq 0xa406
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4aca
movq %rax, %rbx
movq %rsp, %rdi
callq 0xa406
movq %rbx, %rdi
callq 0x3430
nop
// File: /workspace/github_cpp_makefile_star2_O2/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::clear()
void Graph::clear() {
	vsize = 0;
	graph.clear();
	vl.clear();
	TopoOrder.clear();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
andl $0x0, 0xc(%rdi)
addq $0x48, %rdi
callq 0x97ac
movq 0x30(%rbx), %rax
cmpq %rax, 0x38(%rbx)
je 0x4b0b
movq %rax, 0x38(%rbx)
movq 0x60(%rbx), %rax
cmpq %rax, 0x68(%rbx)
je 0x4b19
movq %rax, 0x68(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::strTrimRight(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void Graph::strTrimRight(string& str) {
	string whitespaces(" \t\r\n");
	int index = str.find_last_not_of(whitespaces);
	if (index != string::npos) 
		str.erase(index+1);
	else
		str.clear();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x989b(%rip), %rsi      # 0xe3c8
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x30f0
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3460
cmpl $-0x1, %eax
jne 0x4b5f
andq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax)
jmp 0x4b6f
incl %eax
movslq %eax, %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x3080
leaq 0x8(%rsp), %rdi
callq 0x3120
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O2/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
vector<string>& Graph::split(const string &s, char delim, vector<string> &elems) {
	int begin, end;

	begin=0;
	end=s.find(delim);
	while(end!=string::npos){
		elems.push_back(s.substr(begin, end-begin));
		begin=end+1;
		end=s.find(delim, begin);
	}
	if(begin!=s.size()){
		elems.push_back(s.substr(begin));
	}

	return elems;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
xorl %r13d, %r13d
xorl %edx, %edx
callq 0x3330
movq %rax, %r15
leaq 0x8(%rsp), %r12
movsbl %bpl, %ebp
movslq %r13d, %rdx
cmpl $-0x1, %r15d
je 0x4c09
movl %r15d, %eax
subl %edx, %eax
movslq %eax, %rcx
movq %r12, %rdi
movq %r14, %rsi
callq 0x3290
movq %rbx, %rdi
movq %r12, %rsi
callq 0xab4e
movq %r12, %rdi
callq 0x3120
incl %r15d
movslq %r15d, %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x3330
movl %r15d, %r13d
movq %rax, %r15
jmp 0x4bc2
cmpq %rdx, 0x8(%r14)
je 0x4c37
leaq 0x8(%rsp), %r15
pushq $-0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3290
movq %rbx, %rdi
movq %r15, %rsi
callq 0xab4e
leaq 0x8(%rsp), %rdi
callq 0x3120
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4c4b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O2/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::addEdge(int, int)
void Graph::addEdge(int sid, int tid) {
	if (sid >= vl.size())
		addVertex(sid);
	if (tid >= vl.size())
		addVertex(tid);
	// update edge list
	graph[tid].inList.push_back(sid);
	graph[sid].outList.push_back(tid);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movslq %esi, %rcx
movq 0x38(%rdi), %rax
subq 0x30(%rdi), %rax
sarq $0x4, %rax
cmpq %rcx, %rax
ja 0x4c9d
movq %rbx, %rdi
callq 0x52e2
movq 0x38(%rbx), %rax
subq 0x30(%rbx), %rax
sarq $0x4, %rax
movslq %ebp, %r14
cmpq %r14, %rax
ja 0x4caf
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52e2
imulq $0x30, %r14, %rdi
addq 0x48(%rbx), %rdi
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0x9a0e
movslq (%r14), %rax
movq 0x48(%rbx), %rcx
imulq $0x30, %rax, %rax
leaq (%rcx,%rax), %rdi
addq $0x18, %rdi
leaq 0x8(%rsp), %rsi
callq 0x9a0e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::readGraph2(std::istream&)
void Graph::readGraph2(istream& in) {
	string line;
	int u, v;
	vector<string> edge;

	while(in.eof()!=true){
		getline(in, line);
		if(line!=""){
			edge.clear();
			split(line, '\t', edge);
			if(edge.size()!=2){
				cout << "Input File Error" << endl;
				quit();
			}
//			if(atoi(edge[0].c_str()) < 2004)
//				continue;
			u=atoi(edge[0].c_str());
			v=atoi(edge[1].c_str());
			addEdge(u, v);
			vl[u].outdegree++;
			vl[v].indegree++;
		}
		line.clear();
	}

//	for(int i=0; i<vsize; i++)
//		vl[i].id=i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
andq $0x0, 0x10(%r15)
leaq 0x18(%rsp), %r12
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rbx,%rax)
jne 0x4df3
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3060
movq %r12, %rdi
leaq 0x97a7(%rip), %rsi      # 0xe4f1
callq 0x97b4
testb %al, %al
je 0x4de0
movq %r15, %rdi
callq 0x98a4
movq %r12, %rdi
pushq $0x9
popq %rsi
movq %r15, %rdx
callq 0x4b96
movq (%rsp), %r13
movq 0x8(%rsp), %rax
subq %r13, %rax
cmpq $0x40, %rax
je 0x4da3
movq 0x10252(%rip), %rdi     # 0x14fd8
leaq 0x9664(%rip), %rsi      # 0xe3f1
callq 0x3270
movq %rax, %rdi
callq 0x3140
callq 0x41b8
movq (%rsp), %r13
movq (%r13), %rdi
callq 0x33a0
movl %eax, %ebp
movq 0x20(%r13), %rdi
callq 0x33a0
movl %eax, %r13d
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x4c60
movslq %ebp, %rax
movq 0x30(%r14), %rcx
shlq $0x4, %rax
incl 0xc(%rcx,%rax)
movslq %r13d, %rax
shlq $0x4, %rax
incl 0x8(%rcx,%rax)
andq $0x0, 0x20(%rsp)
movq 0x18(%rsp), %rax
movb $0x0, (%rax)
jmp 0x4d23
movq %rsp, %rdi
callq 0x98ac
leaq 0x18(%rsp), %rdi
callq 0x3120
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x98ac
leaq 0x18(%rsp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3430
nop
// File: /workspace/github_cpp_makefile_star2_O2/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::writeGraph(std::ostream&)
void Graph::writeGraph(ostream& out) {
	cout << "Graph size = " << graph.size() << endl;
	out << "graph_for_greach" << endl;
	out << vl.size() << endl;

	GRA::iterator git;
	EdgeList el;
	EdgeList::iterator eit;
	VertexList::iterator vit;
	int i = 0;
	for (i = 0; i < vl.size(); i++) {
		out << i << ": ";
		el = graph[i].outList;
		for (eit = el.begin(); eit != el.end(); eit++)
			out << (*eit) << " ";
		out << "#" << endl;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0xfeb1(%rip), %rdi      # 0x14fd8
leaq 0x92ea(%rip), %rsi      # 0xe418
callq 0x3270
movq %rax, %rdi
movq 0x50(%r14), %rax
subq 0x48(%r14), %rax
pushq $0x30
popq %rcx
cqto
idivq %rcx
movq %rax, %rsi
callq 0x31d0
movq %rax, %rdi
callq 0x3140
leaq 0x9270(%rip), %rsi      # 0xe3cd
movq %rbx, %rdi
callq 0x3270
movq %rax, %rdi
callq 0x3140
movq 0x38(%r14), %rsi
subq 0x30(%r14), %rsi
sarq $0x4, %rsi
movq %rbx, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x3140
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
andq $0x0, 0x10(%r15)
xorl %r12d, %r12d
leaq 0x9399(%rip), %r13      # 0xe53b
movq 0x38(%r14), %rax
subq 0x30(%r14), %rax
sarq $0x4, %rax
cmpq %r12, %rax
jbe 0x522b
movq %rbx, %rdi
movl %r12d, %esi
callq 0x3420
movq %rax, %rdi
leaq 0x91d8(%rip), %rsi      # 0xe3a0
callq 0x3270
movq 0x48(%r14), %rax
imulq $0x30, %r12, %rcx
leaq (%rax,%rcx), %rsi
addq $0x18, %rsi
movq %r15, %rdi
callq 0x98ce
movq (%rsp), %rbp
cmpq 0x8(%rsp), %rbp
je 0x520c
movl (%rbp), %esi
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
movq %r13, %rsi
callq 0x3270
addq $0x4, %rbp
jmp 0x51e9
movq %rbx, %rdi
leaq 0x9339(%rip), %rsi      # 0xe54f
callq 0x3270
movq %rax, %rdi
callq 0x3140
incq %r12
jmp 0x51a2
movq %rsp, %rdi
callq 0xa406
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5244
movq %rax, %rbx
movq %rsp, %rdi
callq 0xa406
movq %rbx, %rdi
callq 0x3430
nop
// File: /workspace/github_cpp_makefile_star2_O2/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::sortEdges()
void Graph::sortEdges() {
	GRA::iterator git;
	for (git = graph.begin(); git != graph.end(); git++) {
		sort(git->inList.begin(), git->inList.end());
		sort(git->outList.begin(), git->outList.end());
	}	
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %r14
cmpq 0x50(%rbx), %r14
je 0x52da
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0xad95
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rsi
callq 0xad95
addq $0x30, %r14
jmp 0x52b5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::addVertex(int)
void Graph::addVertex(int vid) {
	if (vid >= vl.size()) {
		int size = vl.size();
		for (int i = 0; i < (vid-size+1); i++) {
			graph.push_back(In_OutList());
			vl.push_back(Vertex());
		}
		vsize = vl.size();
	}

	Vertex v;
	vl[vid] = v;

	EdgeList il = EdgeList();
	EdgeList ol = EdgeList();
	In_OutList oil = In_OutList();
	oil.inList = il;
	oil.outList = ol;
	graph[vid] = oil;	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movslq %esi, %r14
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %r14, %rcx
ja 0x5381
movl %esi, %ebp
movq %r14, 0x38(%rsp)
leaq 0x30(%rbx), %r14
subl %ecx, %ebp
leaq 0x48(%rbx), %r15
xorl %r13d, %r13d
movq %rsp, %r12
cmpl %ebp, %r13d
jg 0x536a
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xb196
movq %r12, %rdi
callq 0x95c0
andw $0x0, (%rsp)
andl $0x0, 0xc(%rsp)
andq $0x0, 0x4(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0xb348
incl %r13d
jmp 0x5321
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
movl %ecx, 0xc(%rbx)
movq 0x38(%rsp), %r14
movq %r14, %rcx
shlq $0x4, %rcx
andw $0x0, (%rax,%rcx)
andq $0x0, 0x4(%rax,%rcx)
andl $0x0, 0xc(%rax,%rcx)
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movaps %xmm0, 0x40(%rsp)
andq $0x0, 0x50(%rsp)
movq %rsp, %rdi
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x98ce
leaq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x98ce
imulq $0x30, %r14, %rdi
addq 0x48(%rbx), %rdi
movq %rsp, %rsi
callq 0x99e4
movq %rsp, %rdi
callq 0x95c0
leaq 0x40(%rsp), %rdi
callq 0xa406
leaq 0x60(%rsp), %rdi
callq 0xa406
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x95c0
leaq 0x40(%rsp), %rdi
callq 0xa406
leaq 0x60(%rsp), %rdi
callq 0xa406
jmp 0x543c
movq %rax, %rbx
movq %rsp, %rdi
callq 0x95c0
movq %rbx, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O2/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::num_edges()
int Graph::num_edges() {
	EdgeList el;
	GRA::iterator git;
	int num = 0;
	for (git = graph.begin(); git != graph.end(); git++) {
		el = git->outList;
		num += el.size();
	}
	return num;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
andq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq 0x48(%rdi), %r15
xorl %ebp, %ebp
cmpq 0x50(%rbx), %r15
je 0x549e
addq $0x18, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x98ce
movq 0x8(%rsp), %rax
subq (%rsp), %rax
shrq $0x2, %rax
addl %eax, %ebp
addq $0x18, %r15
jmp 0x5474
movq %rsp, %rdi
callq 0xa406
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xa406
movq %rbx, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O2/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::getRoots()
vector<int> Graph::getRoots() {
	vector<int> roots;

	for(int i=0; i<vsize; i++){
		if(vl[i].indegree==0)
			roots.push_back(i);
	}
	
	return roots;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
leaq 0xc(%rsp), %r15
movl %eax, 0xc(%rsp)
cmpl 0xc(%r14), %eax
jge 0x5536
movslq %eax, %rcx
movq 0x30(%r14), %rdx
shlq $0x4, %rcx
cmpl $0x0, 0x8(%rdx,%rcx)
jne 0x5532
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9a0e
movl 0xc(%rsp), %eax
incl %eax
jmp 0x5507
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xa406
movq %r14, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O2/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::getTails()
vector<int> Graph::getTails(){
	vector<int> tails;

	for(int i=0; i<vsize; i++){
		if(vl[i].outdegree==0)
			tails.push_back(i);
	}

	return tails;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
leaq 0xc(%rsp), %r15
movl %eax, 0xc(%rsp)
cmpl 0xc(%r14), %eax
jge 0x55a6
movslq %eax, %rcx
movq 0x30(%r14), %rdx
shlq $0x4, %rcx
cmpl $0x0, 0xc(%rdx,%rcx)
jne 0x55a2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9a0e
movl 0xc(%rsp), %eax
incl %eax
jmp 0x5577
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xa406
movq %r14, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O2/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::hasEdge(int, int)
bool Graph::hasEdge(int src, int trg) {
	EdgeList el = graph[src].outList;
	EdgeList::iterator ei;
	for (ei = el.begin(); ei != el.end(); ei++)
		if ((*ei) == trg)
			return true;
	return false;

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movslq %esi, %rax
movq 0x48(%rdi), %rcx
imulq $0x30, %rax, %rax
leaq (%rcx,%rax), %rsi
addq $0x18, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x9a2c
movq (%r14), %rdx
movq 0x8(%r14), %rax
movq %rdx, %rcx
cmpq %rax, %rdx
je 0x5604
leaq 0x4(%rcx), %rdx
cmpl %ebx, (%rcx)
jne 0x55f4
cmpq %rax, %rcx
setne %bl
movq %rsp, %rdi
callq 0xa406
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::Graph(Graph const&)
Graph::Graph(const Graph& g) {
	if (this != &g) {
		this->graph = g.graph;
		this->vl = g.vl;
		this->vsize = g.vsize;
		this->name=g.name;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movq %rsi, %r13
movb $0x0, 0x20(%rdi)
leaq 0x30(%rdi), %rbx
movl $0xd8, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3170
cmpq %r13, %r14
je 0x5696
leaq 0x10(%r14), %r15
leaq 0x48(%r14), %r12
leaq 0x48(%r13), %rsi
movq %r12, %rdi
callq 0x9620
leaq 0x30(%r13), %rsi
movq %rbx, %rdi
callq 0x96e8
movl 0xc(%r13), %eax
movl %eax, 0xc(%r14)
addq $0x10, %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x3160
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x20(%rsp)
leaq 0xf0(%r14), %rdi
leaq 0xd8(%r14), %rbp
leaq 0xc0(%r14), %r13
leaq 0xa8(%r14), %rax
movq %rax, 0x8(%rsp)
leaq 0x90(%r14), %rax
movq %rax, 0x10(%rsp)
leaq 0x78(%r14), %rax
movq %rax, 0x18(%rsp)
addq $0x60, %r14
callq 0x95d6
movq %rbp, %rdi
callq 0xa59c
movq %r13, %rdi
callq 0xa59c
movq 0x8(%rsp), %rdi
callq 0x95f8
movq 0x10(%rsp), %rdi
callq 0x95d6
movq 0x18(%rsp), %rdi
callq 0x95d6
movq %r14, %rdi
callq 0xa406
movq %r12, %rdi
callq 0x94f6
movq %rbx, %rdi
callq 0xa4e4
movq %r15, %rdi
callq 0x3120
movq 0x20(%rsp), %rdi
callq 0x3430
nop
// File: /workspace/github_cpp_makefile_star2_O2/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::operator=(Graph const&)
Graph& Graph::operator=(const Graph& g) {
	if (this != &g) {
		graph = g.graph;
		vl = g.vl;
		vsize = g.vsize;
		name=g.name;
	}
	return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x5782
movq %rsi, %r14
addq $0x48, %rsi
leaq 0x48(%rbx), %rdi
callq 0x9620
leaq 0x30(%r14), %rsi
leaq 0x30(%rbx), %rdi
callq 0x96e8
movl 0xc(%r14), %eax
movl %eax, 0xc(%rbx)
addq $0x10, %r14
leaq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x3160
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::layerSeparation()
void Graph::layerSeparation(){
	int i, k;
	int u,v;
	vector<int> indegreeRecord(vsize);
	uint16_t layer=1;
	int vectorsize, tmpsize;

	TopoOrder.resize(vsize);

	k=0;
	for(i=0; i<vsize; i++){
		indegreeRecord[i]=vl[i].indegree;
		if(indegreeRecord[i]==0){
			TopoOrder[k]=i;
			vl[i].topoID =k;
			vl[i].layer=layer;
			k++;
		}
	}


	bool flag=true;
	i=0;
	vectorsize=k;
	while(flag){
		flag=false;
		layer++;
		for(; i<vectorsize; i++){
			u=TopoOrder[i];
			tmpsize=graph[u].outList.size();
			for(int j=0; j<tmpsize; j++){
				v=graph[u].outList[j];
				indegreeRecord[v]--;
				if(indegreeRecord[v]==0){
					flag=true;
					TopoOrder[k]=v;
					vl[v].topoID=k;
					vl[v].layer=layer;
					k++;
				}
			}
		}
		vectorsize=k;
	}


	if(TopoOrder.size()!=vsize){
		cout << "Topology Order Computation Error" << endl;
		quit();
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movslq 0xc(%rdi), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x9a92
leaq 0x60(%rbx), %rdi
movslq 0xc(%rbx), %rsi
callq 0x9ae4
movq 0x10(%rsp), %rcx
movq 0x30(%rbx), %rdx
movq 0x60(%rbx), %rsi
addq $0x8, %rdx
xorl %edi, %edi
xorl %eax, %eax
movslq 0xc(%rbx), %r8
cmpq %r8, %rdi
jge 0x5ad8
movl (%rdx), %r8d
movl %r8d, (%rcx,%rdi,4)
testl %r8d, %r8d
jne 0x5acf
cltq
movl %edi, (%rsi,%rax,4)
movl %eax, -0x4(%rdx)
movw $0x1, -0x8(%rdx)
incl %eax
incq %rdi
addq $0x10, %rdx
jmp 0x5aaa
movb $0x1, %dil
movw $0x1, %cx
xorl %edx, %edx
xorl %esi, %esi
testb $0x1, %dil
je 0x5b61
incl %ecx
movq 0x48(%rbx), %r8
movq 0x60(%rbx), %r9
movslq %esi, %rsi
movslq %eax, %r10
xorl %edi, %edi
cmpq %r10, %rsi
jge 0x5ae3
movslq (%r9,%rsi,4), %r11
imulq $0x30, %r11, %r14
movq 0x18(%r8,%r14), %r11
movq 0x20(%r8,%r14), %r14
subq %r11, %r14
shrq $0x2, %r14
movq 0x10(%rsp), %r15
movq 0x30(%rbx), %r12
testl %r14d, %r14d
cmovlel %edx, %r14d
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x5b5c
movl (%r11,%r13,4), %ebp
movslq %ebp, %rbp
decl (%r15,%rbp,4)
jne 0x5b57
cltq
movl %ebp, (%r9,%rax,4)
shlq $0x4, %rbp
movl %eax, 0x4(%r12,%rbp)
movw %cx, (%r12,%rbp)
incl %eax
movb $0x1, %dil
incq %r13
jmp 0x5b2c
incq %rsi
jmp 0x5afb
movq 0x68(%rbx), %rax
subq 0x60(%rbx), %rax
sarq $0x2, %rax
movslq 0xc(%rbx), %rcx
cmpq %rcx, %rax
je 0x5b96
movq 0xf45b(%rip), %rdi      # 0x14fd8
leaq 0x88c4(%rip), %rsi      # 0xe448
callq 0x3270
movq %rax, %rdi
callq 0x3140
callq 0x41b8
leaq 0x10(%rsp), %rdi
callq 0xa406
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5bb1
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xa406
movq %rbx, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O2/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::countIndegree() const
void Graph::countIndegree() const {
	vector<int> count(100, 0);
	int i;
	string name="data\\"+name+"_count.txt";

	for(i=0; i<vsize; i++){
		if(vl[i].indegree<100){
			count[vl[i].indegree]++;
		}else
			count[99]++;
	}

	ofstream output(name.c_str());
	for(i=0;i<100;i++){
		output << count[i] << endl;
	}

	output.close();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdi, %rbx
leaq 0x38(%rsp), %rdx
andl $0x0, (%rdx)
movq %rsp, %rdi
pushq $0x64
popq %rsi
leaq 0x18(%rsp), %rcx
callq 0x9b68
leaq 0x8463(%rip), %rsi      # 0xe469
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x9bdd
leaq 0x8453(%rip), %rdx      # 0xe46f
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x9bbe
leaq 0x38(%rsp), %rdi
callq 0x3120
movq 0x30(%rbx), %rax
movq (%rsp), %rcx
leaq 0x18c(%rcx), %rdx
addq $0x8, %rax
xorl %esi, %esi
movslq 0xc(%rbx), %rdi
cmpq %rdi, %rsi
jge 0x606d
movslq (%rax), %rdi
cmpq $0x64, %rdi
leaq (%rcx,%rdi,4), %rdi
cmovgeq %rdx, %rdi
incl (%rdi)
incq %rsi
addq $0x10, %rax
jmp 0x604a
movq 0x18(%rsp), %rsi
leaq 0x38(%rsp), %rdi
pushq $0x10
popq %rdx
callq 0x32b0
xorl %r14d, %r14d
leaq 0x38(%rsp), %rbx
cmpq $0x64, %r14
je 0x60aa
movq (%rsp), %rax
movl (%rax,%r14,4), %esi
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x3140
incq %r14
jmp 0x6087
leaq 0x38(%rsp), %rdi
callq 0x3360
leaq 0x38(%rsp), %rdi
callq 0x3380
leaq 0x18(%rsp), %rdi
callq 0x3120
movq %rsp, %rdi
callq 0xa406
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r14
retq
jmp 0x60f1
movq %rax, %rbx
jmp 0x60fe
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
jmp 0x6103
movq %rax, %rbx
jmp 0x6108
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x3380
leaq 0x18(%rsp), %rdi
callq 0x3120
movq %rsp, %rdi
callq 0xa406
movq %rbx, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O2/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::checkLayerSeparation()
void Graph::checkLayerSeparation(){
	int u,v;
	bool flag=false;

	for (u=0; u<vsize; u++){
		for(int j=0; j<graph[u].outList.size(); j++){
			v=graph[u].outList[j];
			if(vl[v].layer<=vl[u].layer || vl[v].topoID <= vl[u].topoID ){
				cout << " checkLayerSeparation: Error" << endl;
				quit();
			}
		}

		for (int j=0; j<graph[u].inList.size(); j++){
			v=graph[u].inList[j];
			if(vl[u].layer-vl[v].layer==1)
				flag=true;
		}
		if(flag||graph[u].inList.size()==0)
			flag=false;
		else{
			cout << " checkLayerSeparation: No good separation" << endl;
			quit();
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
movq 0xeea9(%rip), %r14      # 0x14fd8
leaq 0x8344(%rip), %r15      # 0xe47a
movslq 0xc(%rbx), %rax
cmpq %rax, %rbp
jge 0x622e
imulq $0x30, %rbp, %r12
movq %rbp, (%rsp)
shlq $0x4, %rbp
xorl %r13d, %r13d
movq 0x48(%rbx), %rcx
movq 0x18(%rcx,%r12), %rax
movq 0x20(%rcx,%r12), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r13, %rdx
jbe 0x61ad
movslq (%rax,%r13,4), %rax
movq 0x30(%rbx), %rcx
shlq $0x4, %rax
movzwl (%rcx,%rax), %edx
cmpw (%rcx,%rbp), %dx
jbe 0x6190
addq %rcx, %rax
addq %rbp, %rcx
movl 0x4(%rax), %eax
cmpl 0x4(%rcx), %eax
jg 0x61a8
movq %r14, %rdi
movq %r15, %rsi
callq 0x3270
movq %rax, %rdi
callq 0x3140
callq 0x41b8
incq %r13
jmp 0x6152
addq %r12, %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x2, %rdx
movq 0x30(%rbx), %rsi
addq %rsi, %rbp
xorl %r8d, %r8d
xorl %edi, %edi
cmpq %r8, %rdx
je 0x61f7
movslq (%rax,%r8,4), %r9
movzwl (%rbp), %r10d
shlq $0x4, %r9
movzwl (%rsi,%r9), %r9d
subl %r9d, %r10d
cmpl $0x1, %r10d
sete %r9b
orb %r9b, %dil
incq %r8
jmp 0x61cd
cmpq %rax, %rcx
sete %al
orb %al, %dil
testb $0x1, %dil
jne 0x6222
movq %r14, %rdi
leaq 0x8287(%rip), %rsi      # 0xe497
callq 0x3270
movq %rax, %rdi
callq 0x3140
callq 0x41b8
movq (%rsp), %rbp
incq %rbp
jmp 0x6136
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::checkReverseLayerSeparation()
void Graph::checkReverseLayerSeparation(){
	int u,v;
	bool flag=false;

	for (u=0; u<vsize; u++){
		for(int j=0; j<graph[u].inList.size(); j++){
			v=graph[u].inList[j];
			if(vl[v].layer<=vl[u].layer){
				cout << " checkLayerSeparation: Error" << endl;
				quit();
			}
		}

		for (int j=0; j<graph[u].outList.size(); j++){
			v=graph[u].outList[j];
			if(vl[u].layer-vl[v].layer==1)
				flag=true;
		}
		if(flag||graph[u].outList.size()==0)
			flag=false;
		else{
			cout << " checkLayerSeparation: No good separation" << endl;
			quit();
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
movq 0xed83(%rip), %r14      # 0x14fd8
leaq 0x821e(%rip), %r15      # 0xe47a
movslq 0xc(%rbx), %rax
cmpq %rax, %rbp
jge 0x6346
imulq $0x30, %rbp, %r12
movq %rbp, (%rsp)
shlq $0x4, %rbp
xorl %r13d, %r13d
movq 0x48(%rbx), %rcx
movq (%rcx,%r12), %rax
movq 0x8(%rcx,%r12), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r13, %rdx
jbe 0x62c4
movslq (%rax,%r13,4), %rax
movq 0x30(%rbx), %rcx
shlq $0x4, %rax
movzwl (%rcx,%rax), %eax
cmpw (%rcx,%rbp), %ax
ja 0x62bf
movq %r14, %rdi
movq %r15, %rsi
callq 0x3270
movq %rax, %rdi
callq 0x3140
callq 0x41b8
incq %r13
jmp 0x6278
addq %r12, %rcx
movq 0x18(%rcx), %rax
movq 0x20(%rcx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x2, %rdx
movq 0x30(%rbx), %rsi
addq %rsi, %rbp
xorl %r8d, %r8d
xorl %edi, %edi
cmpq %r8, %rdx
je 0x630f
movslq (%rax,%r8,4), %r9
movzwl (%rbp), %r10d
shlq $0x4, %r9
movzwl (%rsi,%r9), %r9d
subl %r9d, %r10d
cmpl $0x1, %r10d
sete %r9b
orb %r9b, %dil
incq %r8
jmp 0x62e5
cmpq %rax, %rcx
sete %al
orb %al, %dil
testb $0x1, %dil
jne 0x633a
movq %r14, %rdi
leaq 0x816f(%rip), %rsi      # 0xe497
callq 0x3270
movq %rax, %rdi
callq 0x3140
callq 0x41b8
movq (%rsp), %rbp
incq %rbp
jmp 0x625c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::FindStructureEq(std::vector<bool, std::allocator<bool>>&)
int Graph::FindStructureEq(vector<bool>& SEflag){
	SEflag.clear();
	SEflag.resize(vsize,false);
	int secount=0;

	for(int i=0; i<vsize; i++){
		if(i%1000==0)
			cout << i << ": " << secount << endl;
		if(SEflag[i]==false){
			for(int j=i+1; j<vsize; j++){
				if(SEflag[j]==false){
					if(graph[i]==graph[j]){
						secount++;
						SEflag[j]=true;
					}
				}
			}
		}
	}

	return secount;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rax, 0x10(%rsi)
andl $0x0, 0x18(%rsi)
movslq 0xc(%rdi), %rsi
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9d1e
movl $0x3e8, %ebp            # imm = 0x3E8
movl $0x0, 0x4(%rsp)
movslq 0xc(%r14), %rax
cmpq %rax, %r12
jge 0x66d9
movl %r12d, %eax
xorl %edx, %edx
divl %ebp
testl %edx, %edx
jne 0x666c
movq 0xe997(%rip), %rdi      # 0x14fd8
movl %r12d, %esi
callq 0x3420
movq %rax, %rdi
leaq 0x7d4d(%rip), %rsi      # 0xe3a0
callq 0x3270
movq %rax, %rdi
movl 0x4(%rsp), %esi
callq 0x3420
movq %rax, %rdi
callq 0x3140
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9cd4
testq %rdx, (%rax)
jne 0x66d1
imulq $0x30, %r12, %r13
movq %r12, %r15
imulq $0x30, %r15, %rbp
incq %r15
addq $0x30, %rbp
cmpl %r15d, 0xc(%r14)
jle 0x66cc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9cd4
testq %rdx, (%rax)
jne 0x6687
movq 0x48(%r14), %rsi
leaq (%rsi,%r13), %rdi
addq %rbp, %rsi
callq 0x9d8c
testb %al, %al
je 0x6687
incl 0x4(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9cd4
orq %rdx, (%rax)
jmp 0x6683
movl $0x3e8, %ebp            # imm = 0x3E8
incq %r12
jmp 0x6622
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::BFSQuery(unsigned int, unsigned int)
unsigned int Graph::BFSQuery(const unsigned int u, const unsigned int v){
	if(u==v)
		return 0;

	vector<bool> flag(vsize, false);
	set<unsigned int> qvertice;
	unsigned int tmpv;

	flag[u]=true;
	for(int i=0; i<graph[u].outList.size(); i++){
		tmpv=graph[u].outList[i];
		qvertice.insert(tmpv);
	}

	return BFSSubQuery(qvertice, v, 1, flag);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
xorl %r15d, %r15d
cmpl %edx, %esi
je 0x701c
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movslq 0xc(%rdi), %rsi
leaq 0x10(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x40(%rsp), %r12
leaq 0xc(%rsp), %rcx
movq %r12, %rdi
callq 0x9c70
leaq 0x18(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movl %ebp, %r15d
movq %r12, %rdi
movq %r15, %rsi
callq 0x9cd4
orq %rdx, (%rax)
xorl %r13d, %r13d
imulq $0x30, %r15, %rbp
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
movq 0x48(%r14), %rcx
movq 0x18(%rcx,%rbp), %rax
movq 0x20(%rcx,%rbp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x6fee
movl (%rax,%r13,4), %eax
movl %eax, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xc53c
incq %r13
jmp 0x6fbc
leaq 0x10(%rsp), %rsi
pushq $0x1
popq %rcx
leaq 0x40(%rsp), %r8
movq %r14, %rdi
movl %ebx, %edx
callq 0x7052
movl %eax, %r15d
leaq 0x10(%rsp), %rdi
callq 0xa0dc
leaq 0x40(%rsp), %rdi
callq 0x9d0e
movl %r15d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7032
jmp 0x7032
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xa0dc
leaq 0x40(%rsp), %rdi
callq 0x9d0e
movq %rbx, %rdi
callq 0x3430
nop