LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/zimpha[P]MiniSQL/interpreter.cc
// Function: Interpreter::process(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Interpreter::process(std::string line) {
    static std::string cmd;
    for (size_t i = 0; i < line.length(); ++ i) {
        if (line[i] == ';') {
            std::string now(cmd);
            cmd = "";
            if (parse(now)) return true;
        }
        else cmd += line[i];
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, -0x50(%rbp)
movb 0xc11217a(%rip), %al    # 0xc121488
testb %al, %al
je 0xf3fd
cmpq $0x0, 0x8(%rbx)
je 0xf3e8
xorl %r14d, %r14d
leaq 0xc11213d(%rip), %r15   # 0xc121468
leaq -0x70(%rbp), %r12
movq (%rbx), %rax
movb (%rax,%r14), %al
cmpb $0x3b, %al
jne 0xf3d0
leaq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0xc11211b(%rip), %rsi   # 0xc121468
movq 0xc11211c(%rip), %rdx   # 0xc121470
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x88b4
movq 0xc112109(%rip), %rdx   # 0xc121470
movq %r15, %rdi
xorl %esi, %esi
leaq 0x4f42(%rip), %rcx      # 0x142b5
xorl %r8d, %r8d
callq 0x3400
leaq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x88b4
movq -0x50(%rbp), %rdi
movq %r12, %rsi
callq 0xf43c
movl %eax, %r13d
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0xf3b7
callq 0x3270
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xf3c9
callq 0x3270
testb %r13b, %r13b
je 0xf3db
jmp 0xf3ec
movsbl %al, %esi
movq %r15, %rdi
callq 0x3230
incq %r14
cmpq 0x8(%rbx), %r14
jb 0xf32f
xorl %eax, %eax
jmp 0xf3ee
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3695
jmp 0xf316
movq %rax, %rbx
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0xf421
callq 0x3270
jmp 0xf421
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xf433
callq 0x3270
movq %rbx, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O3/zimpha[P]MiniSQL/interpreter.cc
// Function: Interpreter::execfile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Interpreter::execfile(std::string filename) {
    std::ifstream fin((filename).c_str());
    if (!fin) std::cout << "file does not exist" << std::endl;
    else {
        std::string buf;
        while (getline(fin, buf)) {
            int len = buf.size();
            while (len && (buf[len - 1] == '\n' || buf[len - 1] == '\r')) {
                len --;
            }
            if (process(buf.substr(0, len))) return true;
        }
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rdi, %rbx
movq (%rsi), %rsi
leaq -0x270(%rbp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x34c0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x250(%rbp,%rax)
je 0x110bb
movq 0x9f6e(%rip), %rbx      # 0x1afc8
leaq 0x355f(%rip), %rsi      # 0x145c0
movl $0x13, %edx
movq %rbx, %rdi
callq 0x3310
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq 0x9f3c(%rip), %rdi      # 0x1afc8
callq 0x3040
movq %rax, %rdi
callq 0x31c0
xorl %ebx, %ebx
leaq -0x270(%rbp), %rdi
callq 0x3090
movl %ebx, %eax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x48(%rbp), %r15
leaq -0x68(%rbp), %r12
movq -0x270(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x34d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x11184
movl -0x40(%rbp), %eax
testq %rax, %rax
je 0x11133
movq -0x48(%rbp), %rcx
cltq
movzbl -0x1(%rcx,%rax), %edx
cmpl $0xd, %edx
je 0x11127
cmpl $0xa, %edx
jne 0x1112e
decq %rax
jne 0x11118
xorl %eax, %eax
movslq %eax, %rcx
jmp 0x11135
xorl %ecx, %ecx
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x32c0
movq %rbx, %rdi
movq %r12, %rsi
callq 0xf2f0
movl %eax, %r13d
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x11162
callq 0x3270
testb %r13b, %r13b
je 0x110d6
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x1117d
callq 0x3270
movb $0x1, %bl
jmp 0x1109b
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x11099
callq 0x3270
jmp 0x11099
movq %rax, %rbx
jmp 0x111d2
jmp 0x111bd
movq %rax, %rbx
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x111c0
callq 0x3270
jmp 0x111c0
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x111d2
callq 0x3270
leaq -0x270(%rbp), %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O3/zimpha[P]MiniSQL/interpreter.cc
// Function: Interpreter::parseElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
element Interpreter::parseElement(std::string data) {
    if (data[0] == '\'') {
        std::string res;
        res = data.substr(1, data.length() - 2);
        return res;
    }
    if (data.find('.') != -1) {
        char *s;
        return strtof(data.c_str(), &s);
    }
    else {
        char *s;
        return int(strtod(data.c_str(), &s) + 0.5);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdx), %rax
cmpb $0x27, (%rax)
jne 0x1126e
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq 0x8(%r14), %rcx
addq $-0x2, %rcx
leaq -0x78(%rbp), %rdi
movl $0x1, %edx
movq %r14, %rsi
callq 0x32c0
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %r14
movq %r14, %rsi
callq 0x3340
movq (%r14), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x1124f
callq 0x3270
leaq -0x48(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x38(%rbp), %rax
cmpq %r15, %rax
je 0x112bb
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x112c5
movq %r14, %rdi
movl $0x2e, %esi
xorl %edx, %edx
callq 0x3370
cmpq $-0x1, %rax
je 0x11299
movq (%r14), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3380
movq %rbx, %rdi
callq 0x132dc
jmp 0x11305
movq (%r14), %rdi
leaq -0x38(%rbp), %rsi
callq 0x31f0
addsd 0x330b(%rip), %xmm0     # 0x145b8
cvttsd2si %xmm0, %esi
movq %rbx, %rdi
callq 0x132b8
jmp 0x11305
movupd (%r15), %xmm0
movupd %xmm0, (%r14)
movq -0x30(%rbp), %rax
leaq -0x58(%rbp), %rsi
movq %rax, 0x8(%rsi)
movq %r15, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movb $0x0, -0x28(%rbp)
movq %rbx, %rdi
callq 0x1332c
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x112f7
callq 0x3270
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x11305
callq 0x3270
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x11329
callq 0x3270
jmp 0x11329
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x11337
callq 0x3270
movq %rbx, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O3/zimpha[P]MiniSQL/RecordManager.cc
// Function: RecordManager::getString[abi:cxx11](Block&, int)
std::string RecordManager::getString(Block &block, int startPos)
{
    //NOTE: space for the string = user input + 1 !!
    char* str = (char*)block.data + startPos;
    std::string theString(str, strlen(str));
    return theString;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq %ecx, %r14
addq %rdx, %r14
movq %r14, %rdi
callq 0x3110
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
leaq (%rax,%r14), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8952
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x1030, %rsp           # imm = 0x1030
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x50(%rbp), %r15
leaq -0x40(%rbp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
movq %rax, 0x10(%r12)
leaq -0x1050(%rbp), %rdi
movl $0x1000, %edx           # imm = 0x1000
xorl %esi, %esi
callq 0x3160
movq %r15, %rdi
movq %r14, %rsi
callq 0x3150
leaq -0x1050(%rbp), %rsi
movq $0x0, 0x1020(%rsi)
movl $0x0, 0xffc(%rsi)
movq (%rbx), %rdi
callq 0x9898
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x11d5e
callq 0x3270
addq $0x1030, %rsp           # imm = 0x1030
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x11d7f
callq 0x3270
movq %rbx, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movslq %edx, %rax
movb $0x59, (%rsi,%rax)
movq (%rcx), %r12
movq 0x8(%rcx), %rax
movq %rax, -0x68(%rbp)
cmpq %rax, %r12
je 0x122b5
movq %r8, %rbx
movl %edx, %r14d
movq %rsi, %r13
incl %r14d
xorl %r15d, %r15d
movq %rsi, -0x60(%rbp)
movq (%r12,%r15), %rax
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x8(%r12,%r15), %rsi
movq 0x10(%r12,%r15), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x88b4
movl 0x28(%r12,%r15), %eax
movl %eax, -0x30(%rbp)
movq 0x28(%rbx), %rcx
cmpl %eax, 0x20(%rcx,%r15,2)
jne 0x122c4
cmpl $0x2, %eax
leaq -0x78(%rbp), %rcx
je 0x1223c
cmpl $0x1, %eax
je 0x1222b
testl %eax, %eax
jne 0x1228d
movl -0x58(%rbp), %eax
jmp 0x1222e
movl -0x54(%rbp), %eax
movslq %r14d, %rcx
movl %eax, (%r13,%rcx)
addl $0x4, %r14d
jmp 0x1228d
movq %rcx, -0x88(%rbp)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %rdi
callq 0x88b4
movslq %r14d, %rdi
addq %r13, %rdi
movq -0x88(%rbp), %r13
movq %r13, %rsi
callq 0x3260
leaq -0x78(%rbp), %rax
cmpq %rax, %r13
je 0x12280
movq %r13, %rdi
callq 0x3270
movq 0x28(%rbx), %rax
addl 0x24(%rax,%r15,2), %r14d
movq -0x60(%rbp), %r13
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x1229f
callq 0x3270
leaq (%r12,%r15), %rax
addq $0x30, %r15
addq $0x30, %rax
cmpq -0x68(%rbp), %rax
jne 0x121d7
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2444(%rip), %rdi      # 0x1470f
leaq 0x2463(%rip), %rsi      # 0x14735
leaq 0x246d(%rip), %rcx      # 0x14746
movl $0x88, %edx
callq 0x31a0
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x122f8
callq 0x3270
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %edx, %edx
movq %rdx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rdx, 0x28(%rdi)
leaq -0x30(%rbp), %r12
movq %rdx, (%r12)
movq (%r15), %rdi
movq %r14, %rsi
callq 0x94d8
movl 0x100c(%rax), %r13d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8ede
movq -0x30(%rbp), %rdx
movl $0x1000, %eax           # imm = 0x1000
addq %rax, %rdx
movq %rdx, -0x30(%rbp)
cmpl $0x1000, %r13d          # imm = 0x1000
je 0x12c7e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12cc8
movq %rax, %r14
movq %rbx, %rdi
callq 0x859c
movq %r14, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %r12
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r13
movq %r13, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x28(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movq %rax, 0x38(%rdi)
movl $0x0, (%rdi)
movq %rbx, %rdi
callq 0x3150
movl $0x1, 0x40(%r12)
movq (%r15), %rax
movq 0x8(%r15), %rsi
subq %rax, %rsi
je 0x12d9c
movl (%r12), %ecx
sarq $0x5, %rsi
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
addq $0x24, %rax
movl $0x4, %esi
cmpl $0x2, -0x4(%rax)
jb 0x12d8d
jne 0x12db6
movl (%rax), %esi
addl %esi, %ecx
movl %ecx, (%r12)
addq $0x60, %rax
decq %rdx
jne 0x12d7e
movq %r14, %rdi
movq %r15, %rsi
callq 0x13672
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13c2(%rip), %rdi      # 0x1417f
leaq 0x19f4(%rip), %rsi      # 0x147b8
leaq 0x19f7(%rip), %rcx      # 0x147c2
movl $0x14, %edx
callq 0x31a0
movq %rax, %r15
movq %r14, %rdi
callq 0x844c
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x12ded
callq 0x3270
movq %r15, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl 0x28(%rdi), %eax
cmpl $0x2, %eax
je 0x133b6
cmpl $0x1, %eax
je 0x133a5
testl %eax, %eax
jne 0x133ca
movl (%rdi), %esi
movq 0x7c28(%rip), %rdi      # 0x1afc8
jmp 0x3470
cvtss2sd 0x4(%rdi), %xmm0
movq 0x7c17(%rip), %rdi      # 0x1afc8
jmp 0x3410
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
movq 0x7c03(%rip), %rdi      # 0x1afc8
jmp 0x3310
pushq %rbp
movq %rsp, %rbp
leaq 0xdaa(%rip), %rdi       # 0x1417f
leaq 0x13dc(%rip), %rsi      # 0x147b8
leaq 0x1420(%rip), %rcx      # 0x14803
movl $0x47, %edx
callq 0x31a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13431
cmpl $0x2, %eax
je 0x1341f
cmpl $0x1, %eax
je 0x13411
testl %eax, %eax
jne 0x13450
movl (%rdi), %eax
cmpl (%rsi), %eax
setl %al
jmp 0x1342f
movss 0x4(%rsi), %xmm0
ucomiss 0x4(%rdi), %xmm0
seta %al
jmp 0x1342f
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x3050
shrl $0x1f, %eax
popq %rbp
retq
leaq 0x13e7(%rip), %rdi      # 0x1481f
leaq 0x1379(%rip), %rsi      # 0x147b8
leaq 0x13ea(%rip), %rcx      # 0x14830
movl $0x4c, %edx
callq 0x31a0
leaq 0xd28(%rip), %rdi       # 0x1417f
leaq 0x135a(%rip), %rsi      # 0x147b8
leaq 0x13cb(%rip), %rcx      # 0x14830
movl $0x51, %edx
callq 0x31a0
movq %rax, %rdi
callq 0x7e87
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x134e9
cmpl $0x2, %eax
je 0x134be
cmpl $0x1, %eax
je 0x13498
testl %eax, %eax
jne 0x13508
movl (%rdi), %eax
cmpl (%rsi), %eax
jmp 0x134dc
movss 0x4(%rdi), %xmm0
subss 0x4(%rsi), %xmm0
andps 0x12f7(%rip), %xmm0     # 0x147a0
cvtss2sd %xmm0, %xmm0
movsd 0x12fb(%rip), %xmm1     # 0x147b0
ucomisd %xmm0, %xmm1
seta %al
jmp 0x134e7
movq 0x10(%rdi), %rdx
cmpq 0x10(%rsi), %rdx
jne 0x134e1
testq %rdx, %rdx
je 0x134e5
movq 0x8(%rsi), %rsi
movq 0x8(%rdi), %rdi
callq 0x32b0
testl %eax, %eax
sete %al
jmp 0x134e7
xorl %eax, %eax
jmp 0x134e7
movb $0x1, %al
popq %rbp
retq
leaq 0x132f(%rip), %rdi      # 0x1481f
leaq 0x12c1(%rip), %rsi      # 0x147b8
leaq 0x1361(%rip), %rcx      # 0x1485f
movl $0x56, %edx
callq 0x31a0
leaq 0xc70(%rip), %rdi       # 0x1417f
leaq 0x12a2(%rip), %rsi      # 0x147b8
leaq 0x1342(%rip), %rcx      # 0x1485f
movl $0x5b, %edx
callq 0x31a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x108(%rbp), %rdi
callq 0x3cdc
leaq -0x58(%rbp), %r12
movq 0x71ba(%rip), %r15      # 0x1afd8
leaq -0x68(%rbp), %r13
leaq -0x108(%rbp), %rbx
movl $0x3, %edx
movq 0x7193(%rip), %rdi      # 0x1afc8
leaq 0xa53(%rip), %rsi       # 0x1488f
callq 0x3310
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %edx
movq %r15, %rdi
leaq -0x48(%rbp), %rsi
callq 0x34d0
movq %r12, -0x68(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x88b4
movq %rbx, %rdi
movq %r13, %rsi
callq 0xf2f0
movl %eax, %r14d
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x13e97
callq 0x3270
testb %r14b, %r14b
je 0x13e29
leaq -0xc8(%rbp), %rdi
callq 0xba7a
leaq -0x108(%rbp), %rdi
callq 0x82f8
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x13ec6
callq 0x3270
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x13f0d
jmp 0x13ef2
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x13ef5
callq 0x3270
jmp 0x13ef5
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0xba7a
leaq -0x108(%rbp), %rdi
callq 0x82f8
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x13f1f
callq 0x3270
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10c75(%rip), %r12     # 0x15fd8
leaq 0xb0fa(%rip), %rsi      # 0x10464
movl $0x13, %edx
movq %r12, %rdi
callq 0x32e0
movq 0x50(%r15), %rax
subq 0x48(%r15), %rax
sarq $0x4, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
movq %r12, %rdi
callq 0x31c0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %r12, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
leaq 0xb063(%rip), %rsi      # 0x1042d
movl $0x10, %edx
movq %r14, %rdi
callq 0x32e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
movq 0x38(%r15), %rsi
subq 0x30(%r15), %rsi
sarq $0x4, %rsi
movq %r14, %rdi
callq 0x31c0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %r12, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x38(%r15), %rax
cmpq 0x30(%r15), %rax
je 0x5535
xorl %r12d, %r12d
leaq 0xb137(%rip), %rbp      # 0x1059b
movq %r14, %rdi
movl %r12d, %esi
callq 0x3440
movl $0x2, %edx
movq %rax, %rdi
leaq 0xaf22(%rip), %rsi      # 0x103a0
callq 0x32e0
movq 0x48(%r15), %rax
leaq (%r12,%r12,2), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rdx
cmpl $0x1, %ebx
leaq 0x18(%rax,%rcx), %rsi
cmovneq %rdx, %rsi
movq %rsp, %rdi
callq 0xc1f2
movq (%rsp), %r13
cmpq 0x8(%rsp), %r13
je 0x54d4
movl (%r13), %esi
movq %r14, %rdi
callq 0x3440
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x32e0
addq $0x4, %r13
jmp 0x54ab
movl $0x1, %edx
movq %r14, %rdi
leaq 0xb0cc(%rip), %rsi      # 0x105af
callq 0x32e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
incq %r12
movq 0x38(%r15), %rax
subq 0x30(%r15), %rax
sarq $0x4, %rax
cmpq %r12, %rax
ja 0x5464
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5535
callq 0x3260
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5546
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5557
callq 0x3260
movq %rbx, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x0, 0xc(%rdi)
addq $0x48, %rdi
movq 0x48(%rbx), %rsi
callq 0xd2d6
movq 0x30(%rbx), %rax
cmpq %rax, 0x38(%rbx)
je 0x5594
movq %rax, 0x38(%rbx)
movq 0x60(%rbx), %rax
cmpq %rax, 0x68(%rbx)
je 0x55a2
movq %rax, 0x68(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xae68(%rip), %rsi      # 0x10428
leaq 0xae65(%rip), %rdx      # 0x1042c
movq %rsp, %r14
movq %r14, %rdi
callq 0xd306
movq (%r14), %rsi
movq 0x8(%r14), %rcx
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0x3400
cmpl $-0x1, %eax
jne 0x55fa
movq $0x0, 0x8(%rbx)
movq (%rbx), %rdx
jmp 0x560f
incl %eax
movslq %eax, %rdx
movq 0x8(%rbx), %rcx
cmpq %rdx, %rcx
jb 0x562a
movq %rdx, 0x8(%rbx)
addq (%rbx), %rdx
movb $0x0, (%rdx)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x5620
callq 0x3260
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb06d(%rip), %rdi      # 0x1069e
leaq 0xb052(%rip), %rsi      # 0x1068a
xorl %eax, %eax
callq 0x3390
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x5650
callq 0x3260
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/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, (%rsp)
movl %esi, %ebp
movq %rdi, %r14
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x3330
movq %rax, %rbx
movl $0x0, %r13d
cmpl $-0x1, %ebx
je 0x56e3
leaq 0x8(%rsp), %r12
movsbl %bpl, %ebp
movslq %r15d, %rdx
movl %ebx, %eax
subl %edx, %eax
movslq %eax, %rcx
movq %r12, %rdi
movq %r14, %rsi
callq 0x32a0
movq (%rsp), %rdi
movq %r12, %rsi
callq 0xd39c
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x56c5
callq 0x3260
movl %ebx, %r15d
incl %r15d
movslq %r15d, %r13
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x3330
movq %rax, %rbx
cmpl $-0x1, %ebx
jne 0x5690
cmpq %r13, 0x8(%r14)
je 0x5722
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq $-0x1, %rcx
callq 0x32a0
movq (%rsp), %rdi
movq %r15, %rsi
callq 0xd39c
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5722
callq 0x3260
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
jmp 0x5750
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x575a
callq 0x3260
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movslq %esi, %r15
movq 0x38(%rdi), %rax
subq 0x30(%rdi), %rax
sarq $0x4, %rax
cmpq %r15, %rax
ja 0x57a7
movq %r14, %rdi
movl %ebp, %esi
callq 0x613c
movq 0x38(%r14), %rax
subq 0x30(%r14), %rax
sarq $0x4, %rax
movslq %ebx, %r12
cmpq %r12, %rax
ja 0x57b9
movq %r14, %rdi
movl %ebx, %esi
callq 0x613c
movq 0x48(%r14), %rax
leaq (%r12,%r12,2), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rdi
movq 0x8(%rax,%rcx), %rsi
cmpq 0x10(%rax,%rcx), %rsi
je 0x57e1
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x57f5
leaq 0xc(%rsp), %r15
movq %r15, %rdx
callq 0xdd36
movslq (%r15), %r15
movq 0x48(%r14), %rax
leaq (%r15,%r15,2), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rdi
addq $0x18, %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x581b
movl %ebx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x5825
leaq 0x8(%rsp), %rdx
callq 0xdd36
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %r14
leaq 0x28(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb $0x0, (%rcx)
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq (%rsi), %rax
movq -0x18(%rax), %rdi
testb $0x2, 0x20(%rsi,%rdi)
jne 0x59ba
movq %rsi, %rbx
addq %rsi, %rdi
leaq 0x18(%rsp), %r15
movl $0xa, %esi
callq 0x3280
movsbl %al, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x34a0
movq %r15, %rdi
leaq 0xacb1(%rip), %rsi      # 0x10551
callq 0x30c0
testl %eax, %eax
je 0x5993
movq (%rsp), %rbp
movq 0x8(%rsp), %r13
cmpq %rbp, %r13
je 0x58de
movq %rbp, %r12
movq (%r12), %rdi
addq $0x10, %r12
cmpq %r12, %rdi
je 0x58d0
callq 0x3260
addq $0x10, %r12
cmpq %r13, %r12
jne 0x58be
movq %rbp, 0x8(%rsp)
movq %r15, %rdi
movl $0x9, %esi
movq %rsp, %rdx
callq 0x5658
movq (%rsp), %r12
movq 0x8(%rsp), %rax
subq %r12, %rax
cmpq $0x40, %rax
je 0x5953
movl $0x10, %edx
movq 0x106cc(%rip), %rdi     # 0x15fd8
leaq 0xab3e(%rip), %rsi      # 0x10451
callq 0x32e0
movq 0x106b9(%rip), %rcx     # 0x15fd8
movq (%rcx), %rax
movq -0x18(%rax), %rdi
addq %rcx, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq 0x1069b(%rip), %rdi     # 0x15fd8
callq 0x3040
movq %rax, %rdi
callq 0x31d0
callq 0x4948
movq (%rsp), %r12
movq (%r12), %rdi
callq 0x33c0
movl %eax, %r13d
movq 0x20(%r12), %rdi
callq 0x33c0
movl %eax, %r12d
movq %r14, %rdi
movl %r13d, %esi
movl %eax, %edx
callq 0x5762
movslq %r13d, %rax
movq 0x30(%r14), %rcx
shlq $0x4, %rax
incl 0xc(%rcx,%rax)
movslq %r12d, %rax
shlq $0x4, %rax
incl 0x8(%rcx,%rax)
movq $0x0, 0x20(%rsp)
movq 0x18(%rsp), %rax
movb $0x0, (%rax)
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
testb $0x2, 0x20(%rbx,%rax)
je 0x587e
movq %rsp, %rdi
callq 0xc1a8
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x59d6
callq 0x3260
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xc1a8
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x5a04
callq 0x3260
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10193(%rip), %r15     # 0x15fd8
leaq 0xa62c(%rip), %rsi      # 0x10478
movl $0xd, %edx
movq %r15, %rdi
callq 0x32e0
movq 0x50(%r14), %rax
subq 0x48(%r14), %rax
sarq $0x4, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
movq %r15, %rdi
callq 0x31c0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
leaq 0xa581(%rip), %rsi      # 0x1042d
movl $0x10, %edx
movq %rbx, %rdi
callq 0x32e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
movq 0x38(%r14), %rsi
subq 0x30(%r14), %rsi
sarq $0x4, %rsi
movq %rbx, %rdi
callq 0x31c0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x38(%r14), %rax
cmpq 0x30(%r14), %rax
je 0x6012
xorl %r15d, %r15d
leaq 0xa669(%rip), %rbp      # 0x105af
leaq 0xa64e(%rip), %r12      # 0x1059b
movq %rbx, %rdi
movl %r15d, %esi
callq 0x3440
movl $0x2, %edx
movq %rax, %rdi
leaq 0xa439(%rip), %rsi      # 0x103a0
callq 0x32e0
movq 0x48(%r14), %rax
leaq (%r15,%r15,2), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rsi
addq $0x18, %rsi
movq %rsp, %rdi
callq 0xc1f2
movq (%rsp), %r13
cmpq 0x8(%rsp), %r13
je 0x5fb5
movl (%r13), %esi
movq %rbx, %rdi
callq 0x3440
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x32e0
addq $0x4, %r13
jmp 0x5f8c
movl $0x1, %edx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x32e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
incq %r15
movq 0x38(%r14), %rax
subq 0x30(%r14), %rax
sarq $0x4, %rax
cmpq %r15, %rax
ja 0x5f4d
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6012
callq 0x3260
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6023
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6034
callq 0x3260
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x68, %rsp
movq %rdi, %rbx
movslq %esi, %r13
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %rcx
subq %rax, %rcx
movq %rcx, %rdx
sarq $0x4, %rdx
cmpq %r13, %rdx
ja 0x620d
movl %esi, %ebp
cmpl %esi, %edx
jg 0x6206
leaq 0x30(%rbx), %r14
leaq 0x48(%rbx), %r15
subl %edx, %ebp
incl %ebp
movq %rsp, %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xd9d0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x61af
callq 0x3260
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x61bd
callq 0x3260
movw $0x0, (%rsp)
movl $0x0, 0xc(%rsp)
movq $0x0, 0x4(%rsp)
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x61ec
movups (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x38(%rbx)
jmp 0x61f7
movq %r14, %rdi
movq %r12, %rdx
callq 0xdc1a
decl %ebp
jne 0x6184
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
movl %ecx, 0xc(%rbx)
movq %r13, %rcx
shlq $0x4, %rcx
movw $0x0, (%rax,%rcx)
xorl %edx, %edx
movq %rdx, 0x4(%rax,%rcx)
movl $0x0, 0xc(%rax,%rcx)
leaq 0x50(%rsp), %rsi
movq %rdx, 0x10(%rsi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsi)
movq %rdx, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movq %rsp, %rdi
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0xc1f2
leaq 0x18(%rsp), %r14
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0xc1f2
leaq (,%r13,2), %r15
addq %r13, %r15
shlq $0x4, %r15
addq 0x48(%rbx), %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0xc1f2
addq $0x18, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xc1f2
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x62a3
callq 0x3260
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x62b1
callq 0x3260
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x62c0
callq 0x3260
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x62cf
callq 0x3260
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xbe1c
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x62f8
callq 0x3260
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x6314
callq 0x3260
jmp 0x6314
movq %rax, %rbx
movq %rsp, %rdi
callq 0xbe1c
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x0, 0xc(%rsp)
cmpl $0x0, 0xc(%rsi)
jle 0x6453
movq %rsi, %r14
xorl %eax, %eax
leaq 0xc(%rsp), %r15
movslq %eax, %rcx
movq 0x30(%r14), %rdx
shlq $0x4, %rcx
cmpl $0x0, 0x8(%rdx,%rcx)
jne 0x6443
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6438
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6443
movq %rbx, %rdi
movq %r15, %rdx
callq 0xdd36
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
cmpl 0xc(%r14), %eax
jl 0x6410
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6470
callq 0x3260
movq %r14, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x0, 0xc(%rsp)
cmpl $0x0, 0xc(%rsi)
jle 0x64ed
movq %rsi, %r14
xorl %eax, %eax
leaq 0xc(%rsp), %r15
movslq %eax, %rcx
movq 0x30(%r14), %rdx
shlq $0x4, %rcx
cmpl $0x0, 0xc(%rdx,%rcx)
jne 0x64dd
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x64d2
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x64dd
movq %rbx, %rdi
movq %r15, %rdx
callq 0xdd36
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
cmpl 0xc(%r14), %eax
jl 0x64aa
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x650a
callq 0x3260
movq %r14, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebx
movslq %esi, %rax
movq 0x48(%rdi), %rcx
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
leaq (%rcx,%rax), %rsi
addq $0x18, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc352
movq (%r14), %rdi
movq 0x8(%r14), %rax
cmpq %rax, %rdi
je 0x6567
leaq 0x4(%rdi), %rcx
cmpl %ebx, -0x4(%rcx)
sete %bpl
je 0x6569
leaq 0x4(%rcx), %rdx
cmpq %rax, %rcx
movq %rdx, %rcx
jne 0x6550
jmp 0x6569
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x6573
callq 0x3260
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rsi, %r13
movq %rdi, %r15
leaq 0x20(%rdi), %r14
movq %r14, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
leaq 0x30(%rdi), %rbx
movl $0xd8, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3160
cmpq %r13, %r15
je 0x662a
leaq 0x10(%r15), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%r15), %r12
leaq 0x78(%r15), %rax
movq %rax, 0x20(%rsp)
leaq 0x90(%r15), %rax
movq %rax, 0x18(%rsp)
leaq 0xa8(%r15), %rax
movq %rax, 0x10(%rsp)
leaq 0xf0(%r15), %rbp
leaq 0x48(%r13), %rsi
movq %r12, %rdi
callq 0xbed8
leaq 0x30(%r13), %rsi
movq %rbx, %rdi
callq 0xbfa6
movl 0xc(%r13), %eax
movl %eax, 0xc(%r15)
addq $0x10, %r13
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x3150
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
movq %rbp, %rdi
callq 0xbe3e
movq 0xd8(%r15), %rdi
testq %rdi, %rdi
je 0x6655
callq 0x3260
movq 0xc0(%r15), %rdi
testq %rdi, %rdi
je 0x6666
callq 0x3260
movq 0x10(%rsp), %rdi
callq 0xbe84
movq 0x18(%rsp), %rdi
callq 0xbe3e
movq 0x20(%rsp), %rdi
callq 0xbe3e
movq 0x60(%r15), %rdi
testq %rdi, %rdi
je 0x6692
callq 0x3260
movq %r12, %rdi
callq 0xbcd8
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x66a7
callq 0x3260
movq 0x8(%rsp), %rax
movq (%rax), %rdi
cmpq %r14, %rdi
je 0x66b9
callq 0x3260
movq %r13, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6702
movq %rsi, %r14
addq $0x48, %rsi
leaq 0x48(%rbx), %rdi
callq 0xbed8
leaq 0x30(%r14), %rsi
leaq 0x30(%rbx), %rdi
callq 0xbfa6
movl 0xc(%r14), %eax
movl %eax, 0xc(%rbx)
addq $0x10, %r14
leaq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x3150
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc3d2
leaq 0x60(%rbx), %rdi
movslq 0xc(%rbx), %rsi
callq 0xc45e
xorl %r8d, %r8d
cmpl $0x0, 0xc(%rbx)
movl $0x0, %eax
jle 0x6bca
movq 0x10(%rsp), %rcx
movq 0x30(%rbx), %rdx
movq 0x60(%rbx), %rsi
addq $0x8, %rdx
xorl %edi, %edi
xorl %eax, %eax
movl (%rdx), %r9d
movl %r9d, (%rcx,%rdi,4)
testl %r9d, %r9d
jne 0x6bba
cltq
movl %edi, (%rsi,%rax,4)
movl %eax, -0x4(%rdx)
movw $0x1, -0x8(%rdx)
incl %eax
incq %rdi
movslq 0xc(%rbx), %r9
addq $0x10, %rdx
cmpq %r9, %rdi
jl 0x6b9e
movq 0x48(%rbx), %rcx
movq 0x60(%rbx), %rdx
movw $0x1, %si
cmpl %eax, %r8d
jge 0x6c69
incl %esi
movq 0x10(%rsp), %rdi
movslq %r8d, %r8
movslq %eax, %r9
xorl %r11d, %r11d
movl %eax, %r10d
movslq (%rdx,%r8,4), %r14
leaq (%r14,%r14,2), %r15
shlq $0x4, %r15
movq 0x18(%rcx,%r15), %r14
movq 0x20(%rcx,%r15), %r15
subq %r14, %r15
shrq $0x2, %r15
testl %r15d, %r15d
jle 0x6c51
movq 0x30(%rbx), %r12
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movl (%r14,%r13,4), %ebp
movslq %ebp, %rbp
decl (%rdi,%rbp,4)
jne 0x6c49
movslq %r10d, %r10
movl %ebp, (%rdx,%r10,4)
shlq $0x4, %rbp
movl %r10d, 0x4(%r12,%rbp)
movw %si, (%r12,%rbp)
incl %r10d
movb $0x1, %r11b
incq %r13
cmpq %r13, %r15
jne 0x6c22
incq %r8
cmpq %r9, %r8
jne 0x6bf2
movl %eax, %r8d
movl %r10d, %eax
testb $0x1, %r11b
jne 0x6bd6
movq 0x68(%rbx), %rax
subq 0x60(%rbx), %rax
sarq $0x2, %rax
movslq 0xc(%rbx), %rcx
cmpq %rcx, %rax
je 0x6cc9
movq 0xf353(%rip), %rbx      # 0x15fd8
leaq 0x981c(%rip), %rsi      # 0x104a8
movl $0x20, %edx
movq %rbx, %rdi
callq 0x32e0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq 0xf321(%rip), %rdi      # 0x15fd8
callq 0x3040
movq %rax, %rdi
callq 0x31d0
callq 0x4948
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x6cd8
callq 0x3260
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6ce9
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x6cfb
callq 0x3260
movq %rbx, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rdi, %r14
movl $0x190, %edi            # imm = 0x190
callq 0x3290
movq %rax, %rbx
movl $0x190, %edx            # imm = 0x190
movq %rax, %rdi
xorl %esi, %esi
callq 0x3160
leaq 0x92d1(%rip), %rsi      # 0x104c9
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xc698
leaq 0x92c3(%rip), %rsi      # 0x104cf
leaq 0x20(%rsp), %rdi
callq 0x34b0
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x723d
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x7245
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7270
callq 0x3260
movslq 0xc(%r14), %rax
testq %rax, %rax
jle 0x72a6
movq 0x30(%r14), %rcx
leaq 0x18c(%rbx), %rdx
shlq $0x4, %rax
xorl %esi, %esi
movslq 0x8(%rcx,%rsi), %rdi
cmpq $0x64, %rdi
leaq (%rbx,%rdi,4), %rdi
cmovgeq %rdx, %rdi
incl (%rdi)
addq $0x10, %rsi
cmpq %rsi, %rax
jne 0x728a
movq (%rsp), %rsi
leaq 0x20(%rsp), %rdi
movl $0x10, %edx
callq 0x32c0
xorl %r13d, %r13d
leaq 0x20(%rsp), %r14
movl (%rbx,%r13,4), %esi
movq %r14, %rdi
callq 0x3440
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31d0
incq %r13
cmpq $0x64, %r13
jne 0x72c1
leaq 0x20(%rsp), %rdi
callq 0x3350
movq 0xecb7(%rip), %rax      # 0x15fc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x28(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x20(%rsp,%rcx)
callq 0x3220
leaq 0x118(%rsp), %rdi
callq 0x30e0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x734a
callq 0x3260
movq %rbx, %rdi
callq 0x3260
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x7382
movq %rax, %r14
jmp 0x738f
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x7398
jmp 0x739d
movq %rax, %r14
jmp 0x739d
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x3380
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x739d
callq 0x3260
movq %rbx, %rdi
callq 0x3260
movq %r14, %rdi
callq 0x3460
nop