LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: zimpha[P]MiniSQL/indexManager.cc
// Function: IndexManager::less(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, element const&)
set <long> IndexManager::less(const std::string &indexName, const element &e) {
    string name = getIndexFileName(indexName);
    if (!isFileExist(name)) return set <long> ();
    if (name != currentFile) {
        save();
        currentFile = name;
        load();
    }
    set <long> res;
    for (auto it = mp.begin(); it != mp.end() && it->first < e; it++) {
        res.insert(it->second);
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x11a90
movq -0x90(%rbp), %rdi
callq 0x118b0
movb %al, -0x81(%rbp)
jmp 0x1460f
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x14657
jmp 0x1461b
movq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x3190
movq -0xa8(%rbp), %rdi
callq 0x7b90
movl $0x1, -0x50(%rbp)
jmp 0x147be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x147d7
movq -0x98(%rbp), %rsi
addq $0x38, %rsi
leaq -0x40(%rbp), %rdi
callq 0x15b20
testb $0x1, %al
jne 0x14671
jmp 0x146a5
movq -0x98(%rbp), %rdi
callq 0x13450
jmp 0x1467f
movq -0x98(%rbp), %rdi
addq $0x38, %rdi
leaq -0x40(%rbp), %rsi
callq 0x3050
jmp 0x14695
movq -0x98(%rbp), %rdi
callq 0x13ce0
jmp 0x146a3
jmp 0x146a5
movq -0xa8(%rbp), %rdi
movb $0x0, -0x51(%rbp)
callq 0x7b90
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0x15cd0
movq %rax, -0x60(%rbp)
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0x15c40
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x15c10
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xa9(%rbp)
jne 0x146fb
jmp 0x14726
leaq -0x60(%rbp), %rdi
callq 0x15c70
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x24850
movb %al, -0xaa(%rbp)
jmp 0x14718
movb -0xaa(%rbp), %al
movb %al, -0xa9(%rbp)
jmp 0x14726
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x14732
jmp 0x1479f
leaq -0x60(%rbp), %rdi
callq 0x15c70
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
addq $0x30, %rsi
callq 0x7c40
movb %dl, -0xb9(%rbp)
movq %rax, -0xb8(%rbp)
jmp 0x1475d
movb -0xb9(%rbp), %al
movq -0xb8(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movb %al, -0x70(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
callq 0x15c90
movq %rax, -0x80(%rbp)
jmp 0x146c9
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x7be0
jmp 0x147d7
movb $0x1, -0x51(%rbp)
movl $0x1, -0x50(%rbp)
testb $0x1, -0x51(%rbp)
jne 0x147bc
movq -0xa8(%rbp), %rdi
callq 0x7be0
jmp 0x147be
leaq -0x40(%rbp), %rdi
callq 0x35b8
movq -0xa0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x35b8
movq -0x48(%rbp), %rdi
callq 0x34f0
nopl (%rax)
// File: zimpha[P]MiniSQL/indexManager.cc
// Function: IndexManager::inRange(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, element const&, element const&)
set <long> IndexManager::inRange(const std::string &indexName, const element &lhs, const element &rhs) {
    string name = getIndexFileName(indexName);
    if (!isFileExist(name)) return set <long> ();
    if (name != currentFile) {
        save();
        currentFile = name;
        load();
    }
    set <long> res;
    for (auto it = mp.lower_bound(lhs); it != mp.end() && it->first <= rhs; it++) {
        res.insert(it->second);
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x11a90
movq -0x98(%rbp), %rdi
callq 0x118b0
movb %al, -0x89(%rbp)
jmp 0x14853
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x1489b
jmp 0x1485f
movq -0xb0(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x3190
movq -0xb0(%rbp), %rdi
callq 0x7b90
movl $0x1, -0x58(%rbp)
jmp 0x14a19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x14a32
movq -0xa0(%rbp), %rsi
addq $0x38, %rsi
leaq -0x48(%rbp), %rdi
callq 0x15b20
testb $0x1, %al
jne 0x148b5
jmp 0x148e9
movq -0xa0(%rbp), %rdi
callq 0x13450
jmp 0x148c3
movq -0xa0(%rbp), %rdi
addq $0x38, %rdi
leaq -0x48(%rbp), %rsi
callq 0x3050
jmp 0x148d9
movq -0xa0(%rbp), %rdi
callq 0x13ce0
jmp 0x148e7
jmp 0x148e9
movq -0xb0(%rbp), %rdi
movb $0x0, -0x59(%rbp)
callq 0x7b90
movq -0xa0(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0x15d00
movq %rax, -0xb8(%rbp)
jmp 0x14916
movq -0xb8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0xa0(%rbp), %rdi
addq $0x8, %rdi
callq 0x15c40
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x15c10
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xb9(%rbp)
jne 0x14953
jmp 0x1497e
leaq -0x68(%rbp), %rdi
callq 0x15c70
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x24ae0
movb %al, -0xba(%rbp)
jmp 0x14970
movb -0xba(%rbp), %al
movb %al, -0xb9(%rbp)
jmp 0x1497e
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x1498a
jmp 0x149fa
leaq -0x68(%rbp), %rdi
callq 0x15c70
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
addq $0x30, %rsi
callq 0x7c40
movb %dl, -0xc9(%rbp)
movq %rax, -0xc8(%rbp)
jmp 0x149b5
movb -0xc9(%rbp), %al
movq -0xc8(%rbp), %rcx
movq %rcx, -0x80(%rbp)
movb %al, -0x78(%rbp)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
callq 0x15c90
movq %rax, -0x88(%rbp)
jmp 0x14921
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x7be0
jmp 0x14a32
movb $0x1, -0x59(%rbp)
movl $0x1, -0x58(%rbp)
testb $0x1, -0x59(%rbp)
jne 0x14a17
movq -0xb0(%rbp), %rdi
callq 0x7be0
jmp 0x14a19
leaq -0x48(%rbp), %rdi
callq 0x35b8
movq -0xa8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x35b8
movq -0x50(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
nop
// File: zimpha[P]MiniSQL/CatalogManager.cc
// Function: CatalogManager::hasTable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool CatalogManager::hasTable(const std::string &tableName) {
    std::ifstream fin((tableName).c_str());
    if (!fin) return false;
    std::string header;
    fin >> header;
    fin.close();
    return tableName == header;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3120
movq %rax, %rsi
leaq -0x220(%rbp), %rdi
movl $0x8, %edx
callq 0x3540
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x3160
movb %al, -0x251(%rbp)
jmp 0x1b5a0
movb -0x251(%rbp), %al
testb $0x1, %al
jne 0x1b5ac
jmp 0x1b5d6
movb $0x0, -0x1(%rbp)
movl $0x1, -0x230(%rbp)
jmp 0x1b659
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x1b673
leaq -0x250(%rbp), %rdi
movq %rdi, -0x260(%rbp)
callq 0x3410
movq -0x260(%rbp), %rsi
leaq -0x220(%rbp), %rdi
callq 0x33a0
jmp 0x1b5fe
leaq -0x220(%rbp), %rdi
callq 0x30a0
jmp 0x1b60c
movq -0x18(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x7780
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x1, -0x230(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x35b8
jmp 0x1b659
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x35b8
jmp 0x1b673
leaq -0x220(%rbp), %rdi
callq 0x30d0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
leaq -0x220(%rbp), %rdi
callq 0x30d0
movq -0x228(%rbp), %rdi
callq 0x34f0
nopl (%rax,%rax)
// File: zimpha[P]MiniSQL/CatalogManager.cc
// Function: CatalogManager::createTable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<AttrType, std::allocator<AttrType>> const&)
Table CatalogManager::createTable(const std::string &tableName, const std::vector<AttrType> &attrs) {
    assert(!hasTable(tableName));
    Table nt(tableName, attrs);
    nt.write();
    return nt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1b550
xorb $-0x1, %al
testb $0x1, %al
jne 0x1b6c8
jmp 0x1b6ca
jmp 0x1b6e9
leaq 0xbcd9(%rip), %rdi      # 0x273aa
leaq 0xbce7(%rip), %rsi      # 0x273bf
movl $0x17, %edx
leaq 0xbced(%rip), %rcx      # 0x273d1
callq 0x31f0
movq -0x48(%rbp), %rdi
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x23f50
movq -0x48(%rbp), %rdi
callq 0x240c0
jmp 0x1b709
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x1b735
jmp 0x1b72c
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x7920
jmp 0x1b73f
movq -0x48(%rbp), %rdi
callq 0x7920
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x34f0
nopl (%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpb $0x0, 0xc120f9f(%rip)   # 0xc13f4d8
jne 0x1e57e
leaq 0xc120f96(%rip), %rdi   # 0xc13f4d8
callq 0x3530
cmpl $0x0, %eax
je 0x1e57e
leaq 0xc120f65(%rip), %rdi   # 0xc13f4b8
callq 0x3410
movq 0x1aa59(%rip), %rdi     # 0x38fb8
leaq 0xc120f52(%rip), %rsi   # 0xc13f4b8
leaq 0x1ad73(%rip), %rdx     # 0x392e0
callq 0x3270
leaq 0xc120f5f(%rip), %rdi   # 0xc13f4d8
callq 0x31e0
movq $0x0, -0x20(%rbp)
movq -0x88(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x90(%rbp)
callq 0x3460
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0x1e6bd
movq -0x88(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x35a0
movsbl (%rax), %eax
cmpl $0x3b, %eax
jne 0x1e68b
leaq 0xc120ee5(%rip), %rsi   # 0xc13f4b8
movq %rsi, -0x98(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3130
movq -0x98(%rbp), %rdi
leaq 0x8c7e(%rip), %rsi      # 0x2726f
callq 0x33e0
jmp 0x1e5f8
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3130
jmp 0x1e607
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1e6e0
movb %al, -0x99(%rbp)
jmp 0x1e61c
leaq -0x70(%rbp), %rdi
callq 0x35b8
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x1e631
jmp 0x1e663
movb $0x1, -0x1(%rbp)
movl $0x1, -0x74(%rbp)
jmp 0x1e66a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1e680
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x35b8
jmp 0x1e680
movl $0x0, -0x74(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x35b8
movl -0x74(%rbp), %eax
testl %eax, %eax
je 0x1e67e
jmp 0x1e67c
jmp 0x1e6c1
jmp 0x1e6aa
leaq -0x40(%rbp), %rdi
callq 0x35b8
jmp 0x1e6cf
movq -0x88(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x35a0
leaq 0xc120e16(%rip), %rdi   # 0xc13f4b8
movsbl (%rax), %esi
callq 0x31d0
jmp 0x1e6ac
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1e586
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x34f0
nopl (%rax,%rax)
// File: 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
subq $0xd0, %rsp
movq %rdx, -0xb0(%rbp)
movq %rdi, %rax
movq -0xb0(%rbp), %rdi
movq %rax, -0xa8(%rbp)
movq %rax, %rcx
movq %rcx, -0xa0(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x35a0
movsbl (%rax), %eax
cmpl $0x27, %eax
jne 0x20f95
leaq -0x38(%rbp), %rdi
callq 0x3410
movq -0xb0(%rbp), %rdi
callq 0x3460
movq -0xb0(%rbp), %rsi
movq %rax, %rcx
addq $-0x2, %rcx
leaq -0x58(%rbp), %rdi
movl $0x1, %edx
callq 0x32f0
jmp 0x20ef1
leaq -0x38(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
leaq -0x58(%rbp), %rsi
movq %rsi, -0xc8(%rbp)
callq 0x3380
movq -0xc8(%rbp), %rdi
callq 0x35b8
movq -0xc0(%rbp), %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x31a0
movq -0xa8(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x246f0
jmp 0x20f47
leaq -0x88(%rbp), %rdi
callq 0x35b8
leaq -0x38(%rbp), %rdi
callq 0x35b8
jmp 0x21010
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x20f87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x35b8
leaq -0x38(%rbp), %rdi
callq 0x35b8
jmp 0x21020
movq -0xb0(%rbp), %rdi
movl $0x2e, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x33c0
cmpq $-0x1, %rax
je 0x20fd9
movq -0xb0(%rbp), %rdi
callq 0x3120
movq %rax, %rdi
leaq -0x90(%rbp), %rsi
callq 0x33d0
movq -0xa8(%rbp), %rdi
callq 0x24660
jmp 0x21010
movq -0xb0(%rbp), %rdi
callq 0x3120
movq %rax, %rdi
leaq -0x98(%rbp), %rsi
callq 0x3230
movq -0xa8(%rbp), %rdi
movsd 0x656d(%rip), %xmm1     # 0x27570
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %esi
callq 0x24620
movq -0xa0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x34f0
nopl (%rax)
// File: zimpha[P]MiniSQL/RecordManager.cc
// Function: RecordManager::getInt(Block&, int)
int RecordManager::getInt(Block &block, int startPos)
{
    INT info;
    info.charFormat[0] = block.data[startPos];
    info.charFormat[1] = block.data[startPos + 1];
    info.charFormat[2] = block.data[startPos + 2];
    info.charFormat[3] = block.data[startPos + 3];
    return info.intFormat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x17(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x16(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x15(%rbp)
movl -0x18(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: zimpha[P]MiniSQL/RecordManager.cc
// Function: RecordManager::setInt(Block&, int, int)
void RecordManager::setInt(Block &block, int startPos, int num)
{
    INT info;
    info.intFormat = num;
    block.data[startPos] = info.charFormat[0];
    block.data[startPos + 1] = info.charFormat[1];
    block.data[startPos + 2] = info.charFormat[2];
    block.data[startPos + 3] = info.charFormat[3];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movb -0x1c(%rbp), %dl
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movb -0x1b(%rbp), %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movb -0x1a(%rbp), %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movb -0x19(%rbp), %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zimpha[P]MiniSQL/RecordManager.cc
// Function: RecordManager::getFloat(Block&, int)
float RecordManager::getFloat(Block &block, int startPos)
{
    FLOAT info;
    info.charFormat[0] = block.data[startPos];
    info.charFormat[1] = block.data[startPos + 1];
    info.charFormat[2] = block.data[startPos + 2];
    info.charFormat[3] = block.data[startPos + 3];
    return info.floatFormat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x17(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x16(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x15(%rbp)
movss -0x18(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: zimpha[P]MiniSQL/RecordManager.cc
// Function: RecordManager::setFloat(Block&, int, float)
void RecordManager::setFloat(Block &block, int startPos, float num)
{
    FLOAT info;
    info.floatFormat = num;
    block.data[startPos] = info.charFormat[0];
    block.data[startPos + 1] = info.charFormat[1];
    block.data[startPos + 2] = info.charFormat[2];
    block.data[startPos + 3] = info.charFormat[3];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movss %xmm0, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movb -0x1c(%rbp), %dl
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movb -0x1b(%rbp), %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movb -0x1a(%rbp), %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movb -0x19(%rbp), %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x28(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3140
movq %rax, -0x50(%rbp)
leaq -0x2a(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3500
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x3350
jmp 0x229da
leaq -0x2a(%rbp), %rdi
callq 0x3320
movb $0x1, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x22a0f
jmp 0x22a06
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x2a(%rbp), %rdi
callq 0x3320
jmp 0x22a19
movq -0x60(%rbp), %rdi
callq 0x35b8
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x1070, %rsp           # imm = 0x1070
movq %rsi, -0x1058(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1060(%rbp)
leaq -0x1040(%rbp), %rdi
callq 0xfc90
movq -0x1058(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x3050
jmp 0x22af3
movq -0x1060(%rbp), %rdi
movq $0x0, -0x20(%rbp)
leaq -0x1040(%rbp), %rsi
movq %rsi, -0x1068(%rbp)
movl $0xffc, %edx            # imm = 0xFFC
xorl %ecx, %ecx
callq 0x22830
movq -0x1060(%rbp), %rax
movq -0x1068(%rbp), %rsi
movq (%rax), %rdi
callq 0xf440
jmp 0x22b34
leaq -0x1040(%rbp), %rdi
callq 0xfc60
addq $0x1070, %rsp           # imm = 0x1070
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1048(%rbp)
movl %eax, -0x104c(%rbp)
leaq -0x1040(%rbp), %rdi
callq 0xfc60
movq -0x1048(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: 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
subq $0xb0, %rsp
movq %rdx, -0x90(%rbp)
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x7b90
leaq -0x30(%rbp), %rdi
callq 0x23de0
movq $0x0, -0x40(%rbp)
movq -0x90(%rbp), %rsi
movq -0x78(%rbp), %rax
movq (%rax), %rdi
movq -0x40(%rbp), %rdx
callq 0xefc0
movq %rax, -0x98(%rbp)
jmp 0x23d12
movq -0x98(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xfa80
movq -0x78(%rbp), %rdi
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rsi
movl $0xffc, %edx            # imm = 0xFFC
callq 0x227d0
movq -0x88(%rbp), %rdi
movl %eax, -0x34(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x7c40
movb %dl, -0xa1(%rbp)
movq %rax, -0xa0(%rbp)
jmp 0x23d66
movb -0xa1(%rbp), %al
movq -0xa0(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movb %al, -0x68(%rbp)
movq -0x40(%rbp), %rax
addq $0x1000, %rax           # imm = 0x1000
movq %rax, -0x40(%rbp)
cmpl $0x1000, -0x34(%rbp)    # imm = 0x1000
je 0x23cf2
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x23dc7
jmp 0x23dbb
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x7be0
jmp 0x23dd4
movq -0x88(%rbp), %rdi
callq 0x7be0
movq -0x80(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x34f0
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x3410
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x48(%rbp)
callq 0x219f0
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movl $0x0, (%rax)
movq -0x10(%rbp), %rsi
callq 0x3050
jmp 0x23fa3
movq -0x40(%rbp), %rax
movl $0x1, 0x40(%rax)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7750
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x24094
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x21b30
movl 0x20(%rax), %eax
movl %eax, -0x54(%rbp)
testl %eax, %eax
je 0x24027
jmp 0x23ff0
movl -0x54(%rbp), %eax
subl $0x1, %eax
je 0x24036
jmp 0x23ffa
movl -0x54(%rbp), %eax
subl $0x2, %eax
je 0x24045
jmp 0x24062
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9e50
movq -0x38(%rbp), %rdi
callq 0x35b8
jmp 0x240ad
movq -0x40(%rbp), %rax
movslq (%rax), %rcx
addq $0x4, %rcx
movl %ecx, (%rax)
jmp 0x24081
movq -0x40(%rbp), %rax
movslq (%rax), %rcx
addq $0x4, %rcx
movl %ecx, (%rax)
jmp 0x24081
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x21b30
movq %rax, %rcx
movq -0x40(%rbp), %rax
movl 0x24(%rcx), %ecx
addl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x24081
leaq 0x30fa(%rip), %rdi      # 0x27163
leaq 0x3700(%rip), %rsi      # 0x27770
movl $0x14, %edx
leaq 0x36fe(%rip), %rcx      # 0x2777a
callq 0x31f0
jmp 0x24083
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x23fb6
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rdi
callq 0x24c50
jmp 0x240a7
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x28(%rax), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x247e4
jmp 0x247d0
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0x247f8
jmp 0x247da
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x2480f
jmp 0x24825
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq 0x147d7(%rip), %rdi     # 0x38fc8
callq 0x34e0
jmp 0x24844
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
movq 0x147c0(%rip), %rdi     # 0x38fc8
callq 0x3220
jmp 0x24844
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
movq 0x147aa(%rip), %rdi     # 0x38fc8
callq 0x3280
jmp 0x24844
leaq 0x2937(%rip), %rdi      # 0x27163
leaq 0x2f3d(%rip), %rsi      # 0x27770
movl $0x47, %edx
leaq 0x2f7c(%rip), %rcx      # 0x277bb
callq 0x31f0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x28(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jne 0x24876
jmp 0x24895
leaq 0x2f5a(%rip), %rdi      # 0x277d7
leaq 0x2eec(%rip), %rsi      # 0x27770
movl $0x4c, %edx
leaq 0x2f58(%rip), %rcx      # 0x277e8
callq 0x31f0
movq -0x20(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x248b9
jmp 0x248a5
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x248cf
jmp 0x248af
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x248ee
jmp 0x2490a
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x24929
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm1
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
ucomiss %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x24929
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x9020
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x24929
leaq 0x2852(%rip), %rdi      # 0x27163
leaq 0x2e58(%rip), %rsi      # 0x27770
movl $0x51, %edx
leaq 0x2ec4(%rip), %rcx      # 0x277e8
callq 0x31f0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x28(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jne 0x24966
jmp 0x24985
leaq 0x2e6a(%rip), %rdi      # 0x277d7
leaq 0x2dfc(%rip), %rsi      # 0x27770
movl $0x56, %edx
leaq 0x2e97(%rip), %rcx      # 0x27817
callq 0x31f0
movq -0x20(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x249a9
jmp 0x24995
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x249bf
jmp 0x2499f
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x249f6
jmp 0x24a12
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x24a31
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x18(%rbp), %rax
subss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm1
movaps 0x2d84(%rip), %xmm0     # 0x27760
pand %xmm0, %xmm1
movsd 0x2d70(%rip), %xmm0     # 0x27758
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x24a31
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x7780
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x24a31
leaq 0x274a(%rip), %rdi      # 0x27163
leaq 0x2d50(%rip), %rsi      # 0x27770
movl $0x5b, %edx
leaq 0x2deb(%rip), %rcx      # 0x27817
callq 0x31f0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x1, %edi
callq 0x32e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x261c0
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x261ad
movq -0x18(%rbp), %rdi
callq 0x32a0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3410
leaq -0xc8(%rbp), %rdi
callq 0x26300
jmp 0x261e6
jmp 0x261e8
movq 0x12dd9(%rip), %rdi     # 0x38fc8
leaq 0x1651(%rip), %rsi      # 0x27847
callq 0x32c0
jmp 0x261fd
movq 0x12dd4(%rip), %rdi     # 0x38fd8
leaq -0x28(%rbp), %rsi
callq 0x3090
jmp 0x2620f
leaq -0xf8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3130
jmp 0x26221
leaq -0xc8(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x1e510
movb %al, -0xf9(%rbp)
jmp 0x2623c
leaq -0xf8(%rbp), %rdi
callq 0x35b8
movb -0xf9(%rbp), %al
andb $0x1, %al
movb %al, -0xd5(%rbp)
testb $0x1, -0xd5(%rbp)
je 0x262a9
jmp 0x262b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x262e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x262d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0x35b8
jmp 0x262d5
jmp 0x262ab
movb $0x1, %al
testb $0x1, %al
jne 0x261e8
jmp 0x262b7
leaq -0xc8(%rbp), %rdi
callq 0x26320
leaq -0x28(%rbp), %rdi
callq 0x35b8
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
leaq -0xc8(%rbp), %rdi
callq 0x26320
leaq -0x28(%rbp), %rdi
callq 0x35b8
movq -0xd0(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: datourat[P]IP-label-for-graph-reachability/Graph.cpp
// Function: Graph::clear()
void Graph::clear() {
	vsize = 0;
	graph.clear();
	vl.clear();
	TopoOrder.clear();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x0, 0xc(%rdi)
addq $0x48, %rdi
callq 0x11ba0
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0x11bc0
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
callq 0x11be0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x34f0
movq 0x8(%rsp), %rdx
leaq 0x2247f(%rip), %rsi     # 0x283c8
leaq 0x28(%rsp), %rdi
callq 0x33d0
jmp 0x5f55
leaq 0x27(%rsp), %rdi
callq 0x3310
movq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq $-0x1, %rdx
callq 0x3530
movl %eax, 0x10(%rsp)
movslq 0x10(%rsp), %rax
cmpq $-0x1, %rax
je 0x5fd6
movq 0x48(%rsp), %rdi
movl 0x10(%rsp), %eax
incl %eax
movslq %eax, %rsi
movq $-0x1, %rdx
callq 0x3090
jmp 0x5fa0
jmp 0x5fe0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x27(%rsp), %rdi
callq 0x3310
jmp 0x5fef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x31b0
jmp 0x5fef
movq 0x48(%rsp), %rdi
callq 0x33b0
leaq 0x28(%rsp), %rdi
callq 0x31b0
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x34e0
nopl (%rax)
// File: 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:
subq $0x98, %rsp
movb %sil, %al
movq %rdi, 0x90(%rsp)
movb %al, 0x8f(%rsp)
movq %rdx, 0x80(%rsp)
movl $0x0, 0x7c(%rsp)
movq 0x90(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movsbl 0x8f(%rsp), %esi
callq 0x33a0
movl %eax, 0x78(%rsp)
movslq 0x78(%rsp), %rax
cmpq $-0x1, %rax
je 0x60f1
movq 0x80(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x90(%rsp), %rsi
movslq 0x7c(%rsp), %rdx
movl %edx, %ecx
movl 0x78(%rsp), %eax
subl %ecx, %eax
movslq %eax, %rcx
leaq 0x58(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x32e0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x12360
jmp 0x609a
leaq 0x58(%rsp), %rdi
callq 0x31b0
movl 0x78(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
movq 0x90(%rsp), %rdi
movb 0x8f(%rsp), %al
movslq 0x7c(%rsp), %rdx
movsbl %al, %esi
callq 0x33a0
movl %eax, 0x78(%rsp)
jmp 0x6046
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x31b0
jmp 0x618a
movslq 0x7c(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x90(%rsp), %rdi
callq 0x3200
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0x617a
movq 0x80(%rsp), %rax
movq %rax, (%rsp)
movq 0x90(%rsp), %rsi
movslq 0x7c(%rsp), %rdx
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq $-0x1, %rcx
callq 0x32e0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x12360
jmp 0x6154
leaq 0x28(%rsp), %rdi
callq 0x31b0
jmp 0x617a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x31b0
jmp 0x618a
movq 0x80(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movslq 0x1c(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x30, %rdi
callq 0x11600
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jb 0x61e9
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x6e30
movq 0x8(%rsp), %rdi
movslq 0x18(%rsp), %rax
movq %rax, (%rsp)
addq $0x30, %rdi
callq 0x11600
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jb 0x621a
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x6e30
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
movslq 0x18(%rsp), %rsi
callq 0x11d60
movq %rax, %rdi
leaq 0x1c(%rsp), %rsi
callq 0x12660
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x11d60
movq %rax, %rdi
addq $0x18, %rdi
leaq 0x18(%rsp), %rsi
callq 0x12660
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x33e0
leaq 0x38(%rsp), %rdi
callq 0x11d10
movq 0x78(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3520
movb %al, 0x1f(%rsp)
jmp 0x62bf
movb 0x1f(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x643b
movq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x3070
jmp 0x62e2
leaq 0x22208(%rip), %rsi     # 0x284f1
leaq 0x58(%rsp), %rdi
callq 0x11c00
movb %al, 0x1e(%rsp)
jmp 0x62f9
movb 0x1e(%rsp), %al
testb $0x1, %al
jne 0x6306
jmp 0x642c
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x11eb0
movq 0x10(%rsp), %rdx
leaq 0x58(%rsp), %rdi
movl $0x9, %esi
callq 0x6000
jmp 0x632b
leaq 0x38(%rsp), %rdi
callq 0x11d20
cmpq $0x2, %rax
je 0x6398
movq 0x2ec96(%rip), %rdi     # 0x34fd8
leaq 0x220a8(%rip), %rsi     # 0x283f1
callq 0x32c0
movq %rax, 0x8(%rsp)
jmp 0x6355
movq 0x8(%rsp), %rdi
movq 0x2ec67(%rip), %rsi     # 0x34fc8
callq 0x3300
jmp 0x6368
callq 0x4da0
jmp 0x636f
jmp 0x6398
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x11ed0
leaq 0x58(%rsp), %rdi
callq 0x31b0
jmp 0x6457
xorl %eax, %eax
movl %eax, %esi
leaq 0x38(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x11e90
movq %rax, %rdi
callq 0x3120
movq %rax, %rdi
callq 0x3440
movq (%rsp), %rdi
movl %eax, 0x54(%rsp)
movl $0x1, %esi
callq 0x11e90
movq %rax, %rdi
callq 0x3120
movq %rax, %rdi
callq 0x3440
movq 0x20(%rsp), %rdi
movl %eax, 0x50(%rsp)
movl 0x54(%rsp), %esi
movl 0x50(%rsp), %edx
callq 0x61a0
jmp 0x63f4
movq 0x20(%rsp), %rdi
addq $0x30, %rdi
movslq 0x54(%rsp), %rsi
callq 0x11d40
movq 0x20(%rsp), %rdi
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
addq $0x30, %rdi
movslq 0x50(%rsp), %rsi
callq 0x11d40
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
leaq 0x58(%rsp), %rdi
callq 0x33b0
jmp 0x62a5
leaq 0x38(%rsp), %rdi
callq 0x11ed0
leaq 0x58(%rsp), %rdi
callq 0x31b0
addq $0x88, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x2e5cd(%rip), %rdi     # 0x34fd8
leaq 0x21a06(%rip), %rsi     # 0x28418
callq 0x32c0
movq 0x38(%rsp), %rdi
movq %rax, 0x30(%rsp)
addq $0x48, %rdi
callq 0x11f30
movq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0x30a0
movq %rax, %rdi
movq 0x2e587(%rip), %rsi     # 0x34fc8
callq 0x3300
movq 0xa8(%rsp), %rdi
leaq 0x21978(%rip), %rsi     # 0x283cd
callq 0x32c0
movq %rax, %rdi
movq 0x2e564(%rip), %rsi     # 0x34fc8
callq 0x3300
movq 0x38(%rsp), %rdi
movq 0xa8(%rsp), %rax
movq %rax, 0x40(%rsp)
addq $0x30, %rdi
callq 0x11600
movq 0x40(%rsp), %rdi
movq %rax, %rsi
callq 0x30a0
movq %rax, %rdi
movq 0x2e52d(%rip), %rsi     # 0x34fc8
callq 0x3300
leaq 0xa0(%rsp), %rdi
callq 0x11f50
leaq 0x88(%rsp), %rdi
callq 0x11160
leaq 0x80(%rsp), %rdi
callq 0x11f70
leaq 0x78(%rsp), %rdi
callq 0x11f90
movl $0x0, 0x74(%rsp)
movl $0x0, 0x74(%rsp)
movq 0x38(%rsp), %rdi
movslq 0x74(%rsp), %rax
movq %rax, 0x28(%rsp)
addq $0x30, %rdi
callq 0x11600
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jae 0x6c5f
movq 0xa8(%rsp), %rdi
movl 0x74(%rsp), %esi
callq 0x34d0
movq %rax, 0x20(%rsp)
jmp 0x6b22
movq 0x20(%rsp), %rdi
leaq 0x2187e(%rip), %rsi     # 0x283ac
callq 0x32c0
jmp 0x6b35
movq 0x38(%rsp), %rdi
addq $0x48, %rdi
movslq 0x74(%rsp), %rsi
callq 0x11d60
movq %rax, %rsi
addq $0x18, %rsi
leaq 0x88(%rsp), %rdi
callq 0x11fb0
jmp 0x6b5e
leaq 0x88(%rsp), %rdi
callq 0x12270
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x80(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x122e0
movq %rax, 0x50(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x122a0
testb $0x1, %al
jne 0x6ba7
jmp 0x6c1f
movq 0xa8(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x12310
movq 0x10(%rsp), %rdi
movl (%rax), %esi
callq 0x34d0
movq %rax, 0x18(%rsp)
jmp 0x6bd4
movq 0x18(%rsp), %rdi
leaq 0x2195b(%rip), %rsi     # 0x2853b
callq 0x32c0
jmp 0x6be7
jmp 0x6be9
leaq 0x80(%rsp), %rdi
xorl %esi, %esi
callq 0x12320
movq %rax, 0x48(%rsp)
jmp 0x6b7d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x115a0
jmp 0x6c74
movq 0xa8(%rsp), %rdi
leaq 0x21921(%rip), %rsi     # 0x2854f
callq 0x32c0
movq %rax, 0x8(%rsp)
jmp 0x6c3a
movq 0x8(%rsp), %rdi
movq 0x2e382(%rip), %rsi     # 0x34fc8
callq 0x3300
jmp 0x6c4d
jmp 0x6c4f
movl 0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x74(%rsp)
jmp 0x6ae1
leaq 0x88(%rsp), %rdi
callq 0x115a0
addq $0xb8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x34e0
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x11f50
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
callq 0x12490
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
callq 0x12500
movq %rax, 0x38(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x124c0
testb $0x1, %al
jne 0x6d85
jmp 0x6e1d
leaq 0x48(%rsp), %rdi
callq 0x12570
movq %rax, %rdi
callq 0x12270
movq %rax, 0x30(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x12570
movq %rax, %rdi
callq 0x122e0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x12530
leaq 0x48(%rsp), %rdi
callq 0x12570
movq %rax, %rdi
addq $0x18, %rdi
callq 0x12270
movq %rax, 0x20(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x12570
movq %rax, %rdi
addq $0x18, %rdi
callq 0x122e0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x12530
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x12580
movq %rax, 0x10(%rsp)
jmp 0x6d5a
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x138, %rsp            # imm = 0x138
movq %rdi, 0x130(%rsp)
movl %esi, 0x12c(%rsp)
movq 0x130(%rsp), %rdi
movq %rdi, 0x40(%rsp)
movslq 0x12c(%rsp), %rax
movq %rax, 0x48(%rsp)
addq $0x30, %rdi
callq 0x11600
movq %rax, %rcx
movq 0x48(%rsp), %rax
cmpq %rcx, %rax
jb 0x6f95
movq 0x40(%rsp), %rdi
addq $0x30, %rdi
callq 0x11600
movl %eax, 0x128(%rsp)
movl $0x0, 0x124(%rsp)
movl 0x124(%rsp), %eax
movl 0x12c(%rsp), %ecx
subl 0x128(%rsp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x6f7c
movq 0x40(%rsp), %rax
addq $0x48, %rax
movq %rax, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x110(%rsp)
movaps %xmm0, 0x100(%rsp)
movaps %xmm0, 0xf0(%rsp)
leaq 0xf0(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x11380
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x125c0
jmp 0x6f06
leaq 0xf0(%rsp), %rdi
callq 0x11450
movq 0x40(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x28(%rsp)
leaq 0xd4(%rsp), %rdi
callq 0x11c60
movq 0x28(%rsp), %rdi
leaq 0xd4(%rsp), %rsi
callq 0x125f0
movl 0x124(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x124(%rsp)
jmp 0x6e9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe8(%rsp)
movl %eax, 0xe4(%rsp)
leaq 0xf0(%rsp), %rdi
callq 0x11450
jmp 0x70e5
movq 0x40(%rsp), %rdi
addq $0x30, %rdi
callq 0x11600
movq %rax, %rcx
movq 0x40(%rsp), %rax
movl %ecx, 0xc(%rax)
leaq 0xc4(%rsp), %rdi
callq 0x11c60
movq 0x40(%rsp), %rdi
addq $0x30, %rdi
movslq 0x12c(%rsp), %rsi
callq 0x11d40
movups 0xc4(%rsp), %xmm0
movups %xmm0, (%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0xa0(%rsp)
movq $0x0, 0xb0(%rsp)
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x11160
movaps (%rsp), %xmm0
movaps %xmm0, 0x80(%rsp)
movq $0x0, 0x90(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x11160
movaps (%rsp), %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x11380
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x11fb0
jmp 0x7048
leaq 0x68(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x11fb0
jmp 0x705c
movq 0x40(%rsp), %rdi
addq $0x48, %rdi
movslq 0x12c(%rsp), %rsi
callq 0x11d60
movq %rax, %rdi
leaq 0x50(%rsp), %rsi
callq 0x12620
jmp 0x7081
leaq 0x50(%rsp), %rdi
callq 0x11450
leaq 0x80(%rsp), %rdi
callq 0x115a0
leaq 0xa0(%rsp), %rdi
callq 0x115a0
addq $0x138, %rsp            # imm = 0x138
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe8(%rsp)
movl %eax, 0xe4(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x11450
leaq 0x80(%rsp), %rdi
callq 0x115a0
leaq 0xa0(%rsp), %rdi
callq 0x115a0
movq 0xe8(%rsp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)