LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: fffrankkk[P]XmlCode/src/ClassCont.cpp
// Function: CClassCont::GetDate[abi:cxx11]()
string CClassCont::GetDate()
{
    time_t timeNow = time(NULL);
    struct tm stTm;
    localtime_r(&timeNow, &stTm);
    ostringstream ossDate;
    ossDate << 1900 + stTm.tm_year  << "-" << (stTm.tm_mon < 9 ? "0" : "") << stTm.tm_mon + 1 << "-" << \
        (stTm.tm_mday < 10 ? "0" : "") << stTm.tm_mday;
    return ossDate.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x1f8(%rbp)
movq %rdi, %rax
movq %rax, -0x1f0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x5380
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x51e0
leaq -0x1c8(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x5550
movq -0x1e8(%rbp), %rdi
movl -0x3c(%rbp), %esi
addl $0x76c, %esi            # imm = 0x76C
callq 0x5720
movq %rax, -0x1e0(%rbp)
jmp 0x28aef
movq -0x1e0(%rbp), %rdi
leaq 0xe510(%rip), %rsi      # 0x3700d
callq 0x53d0
movq %rax, -0x200(%rbp)
jmp 0x28b0b
movq -0x200(%rbp), %rdi
movl -0x40(%rbp), %eax
subl $0x9, %eax
leaq 0xf200(%rip), %rax      # 0x37d1f
leaq 0xe9e4(%rip), %rsi      # 0x3750a
cmovlq %rax, %rsi
callq 0x53d0
movq %rax, -0x208(%rbp)
jmp 0x28b38
movq -0x208(%rbp), %rdi
movl -0x40(%rbp), %esi
incl %esi
callq 0x5720
movq %rax, -0x210(%rbp)
jmp 0x28b52
movq -0x210(%rbp), %rdi
leaq 0xe4ad(%rip), %rsi      # 0x3700d
callq 0x53d0
movq %rax, -0x218(%rbp)
jmp 0x28b6e
movq -0x218(%rbp), %rdi
movl -0x44(%rbp), %eax
subl $0xa, %eax
leaq 0xf19d(%rip), %rax      # 0x37d1f
leaq 0xe981(%rip), %rsi      # 0x3750a
cmovlq %rax, %rsi
callq 0x53d0
movq %rax, -0x220(%rbp)
jmp 0x28b9b
movq -0x220(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x5720
jmp 0x28bac
movq -0x1f8(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x5410
jmp 0x28bc1
leaq -0x1c8(%rbp), %rdi
callq 0x50e0
movq -0x1f0(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x50e0
movq -0x1d0(%rbp), %rdi
callq 0x5740
nopw (%rax,%rax)
// File: fffrankkk[P]XmlCode/src/ClassCont.cpp
// Function: CClassCont::MergeSpace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void CClassCont::MergeSpace(string& strCont)
{
    size_t zuPos =  isspace(strCont[0]) != 0 ? 0 : string::npos;
    for (size_t zuCount = 1; zuCount < strCont.length(); ++zuCount) {
        if (isspace(strCont[zuCount - 1]) != 0 && isspace(strCont[zuCount]) != 0) {
            if (zuPos == string::npos) {
                zuPos = zuCount;
            }
            continue;
        } else if (zuPos != string::npos){
            strCont[zuPos ++] = strCont[zuCount];
        }
    }
    strCont = strCont.substr(0, zuPos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5820
movsbl (%rax), %edi
callq 0x5080
movl %eax, %edx
movq $-0x1, %rax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x18(%rbp)
movq $0x1, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x55f0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x2a198
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
subq $0x1, %rsi
callq 0x5820
movsbl (%rax), %edi
callq 0x5080
cmpl $0x0, %eax
je 0x2a14d
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5820
movsbl (%rax), %edi
callq 0x5080
cmpl $0x0, %eax
je 0x2a14d
cmpq $-0x1, -0x18(%rbp)
jne 0x2a14b
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x2a187
cmpq $-0x1, -0x18(%rbp)
je 0x2a183
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5820
movb (%rax), %al
movb %al, -0x49(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
callq 0x5820
movb -0x49(%rbp), %cl
movb %cl, (%rax)
jmp 0x2a185
jmp 0x2a187
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2a0e3
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
leaq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x5420
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5500
leaq -0x40(%rbp), %rdi
callq 0x5240
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: fffrankkk[P]XmlCode/src/ClassCont.cpp
// Function: CClassCont::GetPrev(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string CClassCont::GetPrev(const string& strType)
{
    map<string, string>::iterator iterPrev = m_mapPrev.find(strType);
    if (iterPrev != m_mapPrev.end()) {
        return iterPrev->second;
    }
    if (strType[0] == 'C') {
        return "C";
    }
    if (BT_EndsWith(strType, "_S")) {
        return "st";
    }
    if (BT_StartsWith(strType, "vector")) {
        return "vec";
    }
    return string();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x7850
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x78b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7880
testb $0x1, %al
jne 0x2b30c
jmp 0x2b32a
leaq -0x20(%rbp), %rdi
callq 0x78e0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x5190
jmp 0x2b449
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5490
movsbl (%rax), %eax
cmpl $0x43, %eax
jne 0x2b38a
leaq -0x29(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x5750
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0xc02d(%rip), %rsi      # 0x37388
callq 0x7a40
jmp 0x2b362
leaq -0x29(%rbp), %rdi
callq 0x5460
jmp 0x2b449
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x5460
jmp 0x2b453
movq -0x18(%rbp), %rdi
leaq 0xc987(%rip), %rsi      # 0x37d1c
callq 0x2f520
testb $0x1, %al
jne 0x2b3a0
jmp 0x2b3e5
leaq -0x3d(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x5750
movq -0x58(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0xc951(%rip), %rsi      # 0x37d0d
callq 0x7a40
jmp 0x2b3c3
leaq -0x3d(%rbp), %rdi
callq 0x5460
jmp 0x2b449
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x3d(%rbp), %rdi
callq 0x5460
jmp 0x2b453
movq -0x18(%rbp), %rdi
leaq 0xc7d3(%rip), %rsi      # 0x37bc3
callq 0x2f550
testb $0x1, %al
jne 0x2b3fb
jmp 0x2b440
leaq -0x3e(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x5750
movq -0x58(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0xc6bb(%rip), %rsi      # 0x37ad2
callq 0x7a40
jmp 0x2b41e
leaq -0x3e(%rbp), %rdi
callq 0x5460
jmp 0x2b449
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x3e(%rbp), %rdi
callq 0x5460
jmp 0x2b453
movq -0x58(%rbp), %rdi
callq 0x5570
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5740
nopl (%rax)
// File: fffrankkk[P]XmlCode/src/ClassCont.cpp
// Function: CClassCont::GetMacroIfndef(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string CClassCont::GetMacroIfndef(const string& strName)
{
    string strMacro = BT_ToUpperCopy(strName);
    BT_ReplaceAll(strMacro, ".", "_");
    strMacro += "_";
    return string("#ifndef ") + strMacro + "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x5840
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x2f580
jmp 0x2b4bc
leaq -0x40(%rbp), %rdi
callq 0x55a0
leaq 0xbd84(%rip), %rsi      # 0x37250
leaq 0xc8a6(%rip), %rdx      # 0x37d79
leaq -0x38(%rbp), %rdi
callq 0x2f5d0
jmp 0x2b4de
leaq 0xc894(%rip), %rsi      # 0x37d79
leaq -0x38(%rbp), %rdi
callq 0x53c0
jmp 0x2b4f0
leaq -0x91(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x5750
movq -0xc0(%rbp), %rdx
leaq 0xc810(%rip), %rsi      # 0x37d21
leaq -0x90(%rbp), %rdi
callq 0x7a40
jmp 0x2b51f
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x127f0
jmp 0x2b535
movq -0xb8(%rbp), %rdi
leaq 0xc8c5(%rip), %rdx      # 0x37e08
leaq -0x70(%rbp), %rsi
callq 0x264f0
jmp 0x2b54e
leaq -0x70(%rbp), %rdi
callq 0x5240
leaq -0x90(%rbp), %rdi
callq 0x5240
leaq -0x91(%rbp), %rdi
callq 0x5460
leaq -0x38(%rbp), %rdi
callq 0x5240
movq -0xb0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x55a0
jmp 0x2b5ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2b5f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2b5ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2b5de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x5240
leaq -0x90(%rbp), %rdi
callq 0x5240
leaq -0x91(%rbp), %rdi
callq 0x5460
leaq -0x38(%rbp), %rdi
callq 0x5240
movq -0x48(%rbp), %rdi
callq 0x5740
nopl (%rax,%rax)
// File: fffrankkk[P]XmlCode/src/ClassCont.cpp
// Function: CClassCont::GetMacroDefine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string CClassCont::GetMacroDefine(const string& strName)
{
    string strMacro = BT_ToUpperCopy(strName);
    BT_ReplaceAll(strMacro, ".", "_");
    strMacro += "_";
    return string("#define ") + strMacro + "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x5840
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x2f580
jmp 0x2b66c
leaq -0x40(%rbp), %rdi
callq 0x55a0
leaq 0xbbd4(%rip), %rsi      # 0x37250
leaq 0xc6f6(%rip), %rdx      # 0x37d79
leaq -0x38(%rbp), %rdi
callq 0x2f5d0
jmp 0x2b68e
leaq 0xc6e4(%rip), %rsi      # 0x37d79
leaq -0x38(%rbp), %rdi
callq 0x53c0
jmp 0x2b6a0
leaq -0x91(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x5750
movq -0xc0(%rbp), %rdx
leaq 0xc669(%rip), %rsi      # 0x37d2a
leaq -0x90(%rbp), %rdi
callq 0x7a40
jmp 0x2b6cf
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x127f0
jmp 0x2b6e5
movq -0xb8(%rbp), %rdi
leaq 0xc715(%rip), %rdx      # 0x37e08
leaq -0x70(%rbp), %rsi
callq 0x264f0
jmp 0x2b6fe
leaq -0x70(%rbp), %rdi
callq 0x5240
leaq -0x90(%rbp), %rdi
callq 0x5240
leaq -0x91(%rbp), %rdi
callq 0x5460
leaq -0x38(%rbp), %rdi
callq 0x5240
movq -0xb0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x55a0
jmp 0x2b7af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2b7a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2b79a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2b78e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x5240
leaq -0x90(%rbp), %rdi
callq 0x5240
leaq -0x91(%rbp), %rdi
callq 0x5460
leaq -0x38(%rbp), %rdi
callq 0x5240
movq -0x48(%rbp), %rdi
callq 0x5740
nopl (%rax,%rax)
// File: ekg[P]split/splittest.cpp
// Function: main
int main(void) {
    string str = "this will be split on\ttabs\tand spaces";
    vector<string> s = split(str, " \t");
    for (vector<string>::iterator c = s.begin(); c != s.end(); ++c) {
        cout << *c << endl;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x2270
movq -0x98(%rbp), %rdx
leaq 0x2be4(%rip), %rsi      # 0x5004
leaq -0x28(%rbp), %rdi
callq 0x25a0
jmp 0x242b
leaq -0x29(%rbp), %rdi
callq 0x21b0
leaq -0x79(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x2270
movq -0xa0(%rbp), %rdx
leaq 0x2bd8(%rip), %rsi      # 0x502a
leaq -0x78(%rbp), %rdi
callq 0x25a0
jmp 0x245d
leaq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0x2f70
jmp 0x2470
leaq -0x78(%rbp), %rdi
callq 0x20c0
leaq -0x79(%rbp), %rdi
callq 0x21b0
leaq -0x58(%rbp), %rdi
callq 0x2650
movq %rax, -0x88(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x26c0
movq %rax, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x2680
testb $0x1, %al
jne 0x24be
jmp 0x2563
leaq -0x88(%rbp), %rdi
callq 0x26f0
movq %rax, %rsi
movq 0x5b04(%rip), %rdi      # 0x7fd8
callq 0x2150
movq %rax, -0xa8(%rbp)
jmp 0x24e2
movq -0xa8(%rbp), %rdi
movq 0x5ad8(%rip), %rsi      # 0x7fc8
callq 0x2190
jmp 0x24f7
jmp 0x24f9
leaq -0x88(%rbp), %rdi
callq 0x2710
jmp 0x2492
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x21b0
jmp 0x2591
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2541
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x20c0
leaq -0x79(%rbp), %rdi
callq 0x21b0
jmp 0x2588
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2730
jmp 0x2588
movl $0x0, -0x4(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2730
leaq -0x28(%rbp), %rdi
callq 0x20c0
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x20c0
movq -0x38(%rbp), %rdi
callq 0x2260
nopw (%rax,%rax)
// File: junhe[P]libpatterndetector/./pattern.h
// Function: PatternChain<PatternUnit>::show[abi:cxx11]()
string 
PatternChain<T>::show()
{
    typename vector<T>::const_iterator iter;
    ostringstream showstr;

    for ( iter = chain.begin();
            iter != chain.end();
            iter++ )
    {
        showstr << iter->show();
        /*
        vector<off_t>::const_iterator off_iter;
        for ( off_iter = (iter->seq).begin();
                off_iter != (iter->seq).end();
                off_iter++ )
        {
            cout << *off_iter << ", ";
        }
        cout << "^" << iter->cnt << endl;
        */
    }
    return showstr.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1f8(%rbp)
movq %rdi, %rax
movq %rax, -0x1f0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1e8(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3030
leaq -0x190(%rbp), %rdi
callq 0x2140
movq -0x1e8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3050
movq %rax, -0x1a0(%rbp)
leaq -0x198(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x3080
movq -0x198(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x1e8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3100
movq %rax, -0x1a8(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x30c0
testb $0x1, %al
jne 0x2d49
jmp 0x2dd2
leaq -0x18(%rbp), %rdi
callq 0x3130
movq %rax, %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1c8(%rbp), %rdi
callq *%rax
jmp 0x2d66
leaq -0x190(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x20e0
jmp 0x2d7b
leaq -0x1c8(%rbp), %rdi
callq 0x2090
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x3150
movq %rax, -0x1e0(%rbp)
jmp 0x2d19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
jmp 0x2e03
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x2090
jmp 0x2e03
movq -0x1f8(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x2120
jmp 0x2de7
leaq -0x190(%rbp), %rdi
callq 0x2040
movq -0x1f0(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
leaq -0x190(%rbp), %rdi
callq 0x2040
movq -0x1d0(%rbp), %rdi
callq 0x21a0
nopl (%rax,%rax)
// File: junhe[P]libpatterndetector/pattern.cpp
// Function: printVector[abi:cxx11](std::vector<long, std::allocator<long>>)
string
printVector( vector<off_t> vec )
{
    ostringstream oss;
    oss << "PrintVector: " ;
    vector<off_t>::const_iterator it;
    for ( it =  vec.begin() ;
          it != vec.end() ;
          it++ )
    {
        oss << *it << "," ;
    }
    oss << endl;
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rsi, -0x1e0(%rbp)
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0x2140
movq -0x1c8(%rbp), %rdi
leaq 0x912a(%rip), %rsi      # 0xd156
callq 0x20f0
jmp 0x4033
leaq -0x1a0(%rbp), %rdi
callq 0x6980
movq -0x1e0(%rbp), %rdi
callq 0x69a0
movq %rax, -0x1b0(%rbp)
leaq -0x1a8(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x69d0
movq -0x1a8(%rbp), %rax
movq %rax, -0x1a0(%rbp)
movq -0x1e0(%rbp), %rdi
callq 0x6a50
movq %rax, -0x1b8(%rbp)
leaq -0x1a0(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x6a10
testb $0x1, %al
jne 0x409f
jmp 0x4111
leaq -0x1a0(%rbp), %rdi
callq 0x6a80
movq (%rax), %rsi
leaq -0x188(%rbp), %rdi
callq 0x21b0
movq %rax, -0x1e8(%rbp)
jmp 0x40c3
movq -0x1e8(%rbp), %rdi
leaq 0x9093(%rip), %rsi      # 0xd164
callq 0x20f0
jmp 0x40d8
jmp 0x40da
leaq -0x1a0(%rbp), %rdi
xorl %esi, %esi
callq 0x6aa0
movq %rax, -0x1c0(%rbp)
jmp 0x4073
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x2040
jmp 0x4157
movq 0xfeb0(%rip), %rsi      # 0x13fc8
leaq -0x188(%rbp), %rdi
callq 0x2130
jmp 0x4126
movq -0x1d8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x2120
jmp 0x413b
leaq -0x188(%rbp), %rdi
callq 0x2040
movq -0x1d0(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0x21a0
nopw %cs:(%rax,%rax)
// File: junhe[P]libpatterndetector/pattern.cpp
// Function: buildDeltas(std::vector<long, std::allocator<long>>)
vector<off_t>
buildDeltas( vector<off_t> seq ) 
{
    vector<off_t>::iterator it;
    vector<off_t> deltas;
    //ostringstream oss;
    for ( it = seq.begin() ; it != seq.end() ; it++ )
    {
        if ( it > seq.begin() ) {
            deltas.push_back( *it - *(it-1) );
            //oss << (*it - *(it-1)) << "-";
        }
    }
    //mlog(IDX_WARN, "deltas:%s", oss.str().c_str());
    //cout << "in builddeltas: " << seq.size() << " " << deltas.size() << endl; 
    return deltas;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6ae0
movq -0x70(%rbp), %rdi
movb $0x0, -0x19(%rbp)
callq 0x6b00
movq -0x68(%rbp), %rdi
callq 0x69a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x68(%rbp), %rdi
callq 0x6a50
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6b20
testb $0x1, %al
jne 0x41e0
jmp 0x4284
movq -0x68(%rbp), %rdi
callq 0x69a0
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6b60
testb $0x1, %al
jne 0x4200
jmp 0x426e
leaq -0x18(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x6bd0
movq -0x88(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movl $0x1, %esi
callq 0x6bf0
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6bd0
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movq -0x80(%rbp), %rax
movq (%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x6ba0
jmp 0x4255
jmp 0x426e
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x3220
jmp 0x42a4
jmp 0x4270
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x6c30
movq %rax, -0x60(%rbp)
jmp 0x41bd
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x4297
movq -0x70(%rbp), %rdi
callq 0x3220
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x21a0
nopl (%rax)
// File: junhe[P]libpatterndetector/pattern.cpp
// Function: PatternElem::show[abi:cxx11]() const
string 
PatternElem::show() const
{
    vector<off_t>::const_iterator iter;
    ostringstream showstr;
    showstr << "( " ;
    for (iter = seq.begin();
            iter != seq.end();
            iter++ )
    {
        showstr << *iter << " ";
    }
    showstr << ") ^" << cnt << endl;
    return showstr.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c8(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6980
leaq -0x190(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
callq 0x2140
movq -0x1c0(%rbp), %rdi
leaq 0x8dbd(%rip), %rsi      # 0xd166
callq 0x20f0
jmp 0x43b0
movq -0x1c8(%rbp), %rdi
addq $0x8, %rdi
callq 0x6c90
movq %rax, -0x1a8(%rbp)
movq -0x1a8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x1c8(%rbp), %rdi
addq $0x8, %rdi
callq 0x6d00
movq %rax, -0x1b0(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x6cc0
testb $0x1, %al
jne 0x43ff
jmp 0x446e
leaq -0x18(%rbp), %rdi
callq 0x6a80
movq (%rax), %rsi
leaq -0x190(%rbp), %rdi
callq 0x21b0
movq %rax, -0x1e0(%rbp)
jmp 0x4420
movq -0x1e0(%rbp), %rdi
leaq 0x8d39(%rip), %rsi      # 0xd167
callq 0x20f0
jmp 0x4435
jmp 0x4437
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x6aa0
movq %rax, -0x1b8(%rbp)
jmp 0x43d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x2040
jmp 0x44f0
leaq 0x8cf4(%rip), %rsi      # 0xd169
leaq -0x190(%rbp), %rdi
callq 0x20f0
movq %rax, -0x1e8(%rbp)
jmp 0x448a
movq -0x1e8(%rbp), %rdi
movq -0x1c8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x21b0
movq %rax, -0x1f0(%rbp)
jmp 0x44aa
movq -0x1f0(%rbp), %rdi
movq 0xfb10(%rip), %rsi      # 0x13fc8
callq 0x2130
jmp 0x44bf
movq -0x1d8(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x2120
jmp 0x44d4
leaq -0x190(%rbp), %rdi
callq 0x2040
movq -0x1d0(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x198(%rbp), %rdi
callq 0x21a0
nopl (%rax)
// File: junhe[P]libpatterndetector/pattern.cpp
// Function: PatternUnit::isSeqRepeating()
bool
PatternUnit::isSeqRepeating()
{
    vector<off_t>::iterator it;
    bool allrepeat = true;
    for ( it = seq.begin();
          it != seq.end();
          it++ )
    {
        if ( it != seq.begin()
             && *it != *(it-1) ) {
            allrepeat = false;
            break;
        }
    }
    return allrepeat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x6ae0
movq -0x48(%rbp), %rdi
movb $0x1, -0x11(%rbp)
addq $0x8, %rdi
callq 0x69a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x6a50
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6b20
testb $0x1, %al
jne 0x4941
jmp 0x49cd
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x69a0
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6b20
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x49(%rbp)
jne 0x496d
jmp 0x49a8
leaq -0x10(%rbp), %rdi
callq 0x6bd0
movq (%rax), %rax
movq %rax, -0x58(%rbp)
leaq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x6bf0
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6bd0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq (%rcx), %rax
setne %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x49b1
jmp 0x49b7
movb $0x0, -0x11(%rbp)
jmp 0x49cd
jmp 0x49b9
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x6c30
movq %rax, -0x40(%rbp)
jmp 0x491a
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: junhe[P]libpatterndetector/pattern.cpp
// Function: PatternUnit::compressRepeats()
void
PatternUnit::compressRepeats()
{
    if ( isSeqRepeating() && size() > 1 ) {
        cnt = size();
        off_t tmp = seq[0];
        seq.clear();
        seq.push_back(tmp);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x48e0
testb $0x1, %al
jne 0x49ff
jmp 0x4a52
movq -0x18(%rbp), %rdi
callq 0x4300
cmpl $0x1, %eax
jle 0x4a52
movq -0x18(%rbp), %rdi
callq 0x4300
movq -0x18(%rbp), %rdi
cltq
movq %rax, 0x20(%rdi)
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6d30
movq -0x18(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x10(%rbp)
addq $0x8, %rdi
callq 0x6d50
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq -0x10(%rbp), %rsi
callq 0x6d70
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: junhe[P]libpatterndetector/pattern.cpp
// Function: PatternUnit::serialize[abi:cxx11]()
string 
PatternUnit::serialize()
{
    string buf; //let me put it in string and see if it works
    header_t seqbodysize;
    header_t totalsize;

    totalsize = bodySize(); 
    
    appendToBuffer(buf, &totalsize, sizeof(totalsize));
    appendToBuffer(buf, &init, sizeof(init));
    appendToBuffer(buf, &cnt, sizeof(cnt));
    seqbodysize = seq.size()*sizeof(off_t);
    appendToBuffer(buf, &(seqbodysize), sizeof(header_t));
    if (seqbodysize > 0 ) {
        appendToBuffer(buf, &seq[0], seqbodysize);
    }
    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x2150
movq -0x40(%rbp), %rdi
callq 0x4500
movq -0x38(%rbp), %rdi
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
movl $0x4, %edx
callq 0x3f60
jmp 0x4aac
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
addq $0x28, %rsi
movl $0x8, %edx
callq 0x3f60
jmp 0x4ac4
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
addq $0x20, %rsi
movl $0x8, %edx
callq 0x3f60
jmp 0x4adc
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0x6c70
movq -0x38(%rbp), %rdi
shll $0x3, %eax
movl %eax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0x3f60
jmp 0x4b03
cmpl $0x0, -0x18(%rbp)
jle 0x4b44
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6d30
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movl -0x18(%rbp), %edx
callq 0x3f60
jmp 0x4b2b
jmp 0x4b44
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2090
jmp 0x4b61
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4b57
movq -0x38(%rbp), %rdi
callq 0x2090
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x21a0
nopw (%rax,%rax)
// File: junhe[P]libpatterndetector/pattern.cpp
// Function: PatternUnit::deSerialize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void 
PatternUnit::deSerialize(string buf)
{
    header_t totalsize;
    int cur_start = 0;
    header_t seqbodysize;

    readFromBuf(buf, &totalsize, cur_start, sizeof(totalsize));
    readFromBuf(buf, &init, cur_start, sizeof(init));
    readFromBuf(buf, &cnt, cur_start, sizeof(cnt));
    readFromBuf(buf, &seqbodysize, cur_start, sizeof(header_t));
    if ( seqbodysize > 0 ) {
        seq.resize(seqbodysize/sizeof(off_t));
        readFromBuf(buf, &seq[0], cur_start, seqbodysize); 
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %rax
movq -0x38(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x18(%rbp)
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
movl $0x4, %ecx
callq 0x3f90
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
addq $0x28, %rsi
leaq -0x18(%rbp), %rdx
movl $0x8, %ecx
callq 0x3f90
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
addq $0x20, %rsi
leaq -0x18(%rbp), %rdx
movl $0x8, %ecx
callq 0x3f90
movq -0x28(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
leaq -0x18(%rbp), %rdx
movl $0x4, %ecx
callq 0x3f90
cmpl $0x0, -0x1c(%rbp)
jle 0x4c39
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
shrq $0x3, %rsi
callq 0x6de0
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6d30
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movl -0x1c(%rbp), %ecx
leaq -0x18(%rbp), %rdx
callq 0x3f90
addq $0x40, %rsp
popq %rbp
retq
nop
// File: junhe[P]libpatterndetector/pattern.cpp
// Function: PatternUnit::show[abi:cxx11]() const
string
PatternUnit::show() const
{
    ostringstream showstr;
    showstr << init << " ... ";
    showstr << PatternElem::show();
    return showstr.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1e0(%rbp)
movq %rdi, %rax
movq %rax, -0x1d8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1d0(%rbp)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0x2140
movq -0x1d0(%rbp), %rax
movq -0x1c8(%rbp), %rdi
movq 0x28(%rax), %rsi
callq 0x21b0
movq %rax, -0x1c0(%rbp)
jmp 0x4ca2
movq -0x1c0(%rbp), %rdi
leaq 0x84f1(%rip), %rsi      # 0xd1a1
callq 0x20f0
jmp 0x4cb7
movq -0x1d0(%rbp), %rsi
leaq -0x1b8(%rbp), %rdi
callq 0x4350
jmp 0x4ccc
leaq -0x188(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x20e0
jmp 0x4ce1
leaq -0x1b8(%rbp), %rdi
callq 0x2090
movq -0x1e0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x2120
jmp 0x4d02
leaq -0x188(%rbp), %rdi
callq 0x2040
movq -0x1d8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x4d50
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x2090
leaq -0x188(%rbp), %rdi
callq 0x2040
movq -0x190(%rbp), %rdi
callq 0x21a0
nopl (%rax,%rax)
// File: junhe[P]libpatterndetector/./pattern.h
// Function: PatternChain<PatternUnit>::isPopSafe(int)
bool
PatternChain<T>::isPopSafe( int t ) 
{
    typename vector<T>::reverse_iterator rit;
    
    int total = 0;
    rit = chain.rbegin();
    while ( rit != chain.rend()
            && total < t )
    {
        total += rit->size();
        rit++;
    }
    return total == t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xbb00
movq -0x40(%rbp), %rsi
movl $0x0, -0x1c(%rbp)
addq $0x8, %rsi
leaq -0x28(%rbp), %rdi
callq 0xbb20
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x40(%rbp), %rsi
addq $0x8, %rsi
leaq -0x30(%rbp), %rdi
callq 0xbba0
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xbb70
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x41(%rbp)
jne 0x776c
jmp 0x7778
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
setl %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x7781
jmp 0x77a9
leaq -0x18(%rbp), %rdi
callq 0xbbf0
movq %rax, %rdi
callq 0x4300
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0xbc30
jmp 0x7740
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
sete %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: junhe[P]libpatterndetector/./pattern.h
// Function: PatternChain<PatternUnit>::popElem(int)
bool
PatternChain<T>::popElem ( int t )
{
    if ( !isPopSafe(t) ) {
        return false;
    }

    int total = 0; // the number of elem already popped out
    while ( !chain.empty() && total < t ) {
        total += top().size();
        chain.pop_back();
    }
    assert( total == t );

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl -0x14(%rbp), %esi
callq 0x7700
testb $0x1, %al
jne 0x77ec
movb $0x0, -0x1(%rbp)
jmp 0x7882
movl $0x0, -0x18(%rbp)
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
callq 0x74d0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x51(%rbp)
jne 0x7818
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
setl %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x7821
jmp 0x7855
movq -0x50(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x7930
leaq -0x48(%rbp), %rdi
callq 0x4300
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2bf0
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
callq 0xbd90
jmp 0x77f3
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x785f
jmp 0x787e
leaq 0x5ab6(%rip), %rdi      # 0xd31c
leaq 0x5aba(%rip), %rsi      # 0xd327
movl $0xeb, %edx
leaq 0x5aba(%rip), %rcx      # 0xd333
callq 0x20a0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: junhe[P]libpatterndetector/./pattern.h
// Function: PatChain<PatternUnit>::show[abi:cxx11]()
virtual string show()
        {
            typename vector<T>::const_iterator iter;
            ostringstream showstr;
            for ( iter = this->chain.begin();
                    iter != this->chain.end();
                    iter++ )
            {
                vector<off_t>::const_iterator off_iter;
                showstr << iter->init << "- (" ;
                for ( off_iter = (iter->seq).begin();
                        off_iter != (iter->seq).end();
                        off_iter++ )
                {
                    showstr << *off_iter << ", ";
                }
                showstr << ")^" << iter->cnt << endl;
            }
            return showstr.str(); 
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x1f8(%rbp)
movq %rdi, %rax
movq %rax, -0x1f0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1e8(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3030
leaq -0x190(%rbp), %rdi
callq 0x2140
movq -0x1e8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3050
movq %rax, -0x1a0(%rbp)
leaq -0x198(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x3080
movq -0x198(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x1e8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3100
movq %rax, -0x1a8(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x30c0
testb $0x1, %al
jne 0x8c59
jmp 0x8ddf
leaq -0x1b0(%rbp), %rdi
callq 0x6980
leaq -0x18(%rbp), %rdi
callq 0x3130
movq 0x28(%rax), %rsi
leaq -0x190(%rbp), %rdi
callq 0x21b0
movq %rax, -0x200(%rbp)
jmp 0x8c87
movq -0x200(%rbp), %rdi
leaq 0x4632(%rip), %rsi      # 0xd2c7
callq 0x20f0
jmp 0x8c9c
leaq -0x18(%rbp), %rdi
callq 0x3130
movq %rax, %rdi
addq $0x8, %rdi
callq 0x6c90
movq %rax, -0x1c8(%rbp)
movq -0x1c8(%rbp), %rax
movq %rax, -0x1b0(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3130
movq %rax, %rdi
addq $0x8, %rdi
callq 0x6d00
movq %rax, -0x1d0(%rbp)
leaq -0x1b0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x6cc0
testb $0x1, %al
jne 0x8cfb
jmp 0x8d73
leaq -0x1b0(%rbp), %rdi
callq 0x6a80
movq (%rax), %rsi
leaq -0x190(%rbp), %rdi
callq 0x21b0
movq %rax, -0x208(%rbp)
jmp 0x8d1f
movq -0x208(%rbp), %rdi
leaq 0x459e(%rip), %rsi      # 0xd2cb
callq 0x20f0
jmp 0x8d34
jmp 0x8d36
leaq -0x1b0(%rbp), %rdi
xorl %esi, %esi
callq 0x6aa0
movq %rax, -0x1d8(%rbp)
jmp 0x8cc6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x2040
jmp 0x8e10
leaq 0x4554(%rip), %rsi      # 0xd2ce
leaq -0x190(%rbp), %rdi
callq 0x20f0
movq %rax, -0x210(%rbp)
jmp 0x8d8f
leaq -0x18(%rbp), %rdi
callq 0x3130
movq -0x210(%rbp), %rdi
movq 0x20(%rax), %rsi
callq 0x21b0
movq %rax, -0x218(%rbp)
jmp 0x8db1
movq -0x218(%rbp), %rdi
movq 0xb209(%rip), %rsi      # 0x13fc8
callq 0x2130
jmp 0x8dc6
jmp 0x8dc8
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x3150
movq %rax, -0x1e0(%rbp)
jmp 0x8c29
movq -0x1f8(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x2120
jmp 0x8df4
leaq -0x190(%rbp), %rdi
callq 0x2040
movq -0x1f0(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0x21a0
nopl (%rax)
// File: eschwabe[P]interview-practice/src/allsubsets.cpp
// Function: main
int main()
{
    set<int> s{1,2,3,4};
    vector<set<int>> output;

    GetSubsets(s, &output);

    for(auto o : output) {
        for(auto v : o) {
            cout << v << " ";
        }
        cout << endl;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movl $0x0, -0x4(%rbp)
movl $0x1, -0x58(%rbp)
movl $0x2, -0x54(%rbp)
movl $0x3, -0x50(%rbp)
movl $0x4, -0x4c(%rbp)
leaq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x4, -0x40(%rbp)
leaq -0x5a(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x1c20
movq -0xf8(%rbp), %r8
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq -0x59(%rbp), %rcx
callq 0x1c40
jmp 0x15cc
leaq -0x5a(%rbp), %rdi
callq 0x1d10
leaq -0x88(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x1d60
movq -0x100(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x12a0
jmp 0x15fa
leaq -0x88(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rdi
callq 0x19a0
movq %rax, -0x98(%rbp)
movq -0x90(%rbp), %rdi
callq 0x19d0
movq %rax, -0xa0(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x1a00
testb $0x1, %al
jne 0x164a
jmp 0x177f
leaq -0x98(%rbp), %rdi
callq 0x1a40
movq %rax, %rsi
leaq -0xd0(%rbp), %rdi
callq 0x1a60
jmp 0x1667
leaq -0xd0(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0xd8(%rbp), %rdi
callq 0x17f0
movq %rax, -0xe0(%rbp)
movq -0xd8(%rbp), %rdi
callq 0x1820
movq %rax, -0xe8(%rbp)
leaq -0xe0(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x1850
testb $0x1, %al
jne 0x16b7
jmp 0x174d
leaq -0xe0(%rbp), %rdi
callq 0x1880
movl (%rax), %eax
movl %eax, -0xec(%rbp)
movl -0xec(%rbp), %esi
movq 0x7900(%rip), %rdi      # 0x8fd8
callq 0x1140
movq %rax, -0x108(%rbp)
jmp 0x16e6
movq -0x108(%rbp), %rdi
leaq 0x3910(%rip), %rsi      # 0x5004
callq 0x10b0
jmp 0x16fb
jmp 0x16fd
leaq -0xe0(%rbp), %rdi
callq 0x1d30
jmp 0x169b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x5a(%rbp), %rdi
callq 0x1d10
jmp 0x17bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x17a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x1b50
jmp 0x17a7
movq 0x7884(%rip), %rdi      # 0x8fd8
movq 0x786d(%rip), %rsi      # 0x8fc8
callq 0x10f0
jmp 0x1762
leaq -0xd0(%rbp), %rdi
callq 0x1b50
leaq -0x98(%rbp), %rdi
callq 0x1b70
jmp 0x162e
movl $0x0, -0x4(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x1b90
leaq -0x38(%rbp), %rdi
callq 0x1b50
movl -0x4(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
leaq -0x88(%rbp), %rdi
callq 0x1b90
leaq -0x38(%rbp), %rdi
callq 0x1b50
movq -0x68(%rbp), %rdi
callq 0x1150
nopw %cs:(%rax,%rax)
nop
// File: npaster[P]gmsh_tools/gmshElement.cpp
// Function: gmsh::Node::print() const
void
Node::print() const
{
   std::cout << "--------------- Node --------------" << std::endl;
   std::cout << "Index: " << m_index << std::endl;
   std::cout << "Reference: " << m_ref << std::endl;
   std::cout << "Coordinates: " << std::endl;
   std::cout << "[x, y, z] = [ " << m_coordinate[0] << " " << m_coordinate[1] << " "
             << m_coordinate[2] << " ];" << std::endl;
   std::cout << "--------------------------------------" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x2e9dd(%rip), %rdi     # 0x30fd8
leaq 0x1ea02(%rip), %rsi     # 0x21004
callq 0x21b0
movq %rax, %rdi
movq 0x2e9b7(%rip), %rsi     # 0x30fc8
callq 0x21e0
movq 0x2e9bb(%rip), %rdi     # 0x30fd8
leaq 0x1ea04(%rip), %rsi     # 0x21028
callq 0x21b0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x2060
movq %rax, %rdi
movq 0x2e985(%rip), %rsi     # 0x30fc8
callq 0x21e0
movq 0x2e989(%rip), %rdi     # 0x30fd8
leaq 0x1e9da(%rip), %rsi     # 0x21030
callq 0x21b0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x2060
movq %rax, %rdi
movq 0x2e953(%rip), %rsi     # 0x30fc8
callq 0x21e0
movq 0x2e957(%rip), %rdi     # 0x30fd8
leaq 0x1e9b4(%rip), %rsi     # 0x2103c
callq 0x21b0
movq %rax, %rdi
movq 0x2e931(%rip), %rsi     # 0x30fc8
callq 0x21e0
movq 0x2e935(%rip), %rdi     # 0x30fd8
leaq 0x1e9a0(%rip), %rsi     # 0x2104a
callq 0x21b0
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3330
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x2320
movq %rax, %rdi
leaq 0x1f827(%rip), %rsi     # 0x21efe
callq 0x21b0
movq -0x18(%rbp), %rdi
movq %rax, -0x20(%rbp)
movl $0x1, %esi
callq 0x3330
movq -0x20(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x2320
movq %rax, %rdi
leaq 0x1f7f9(%rip), %rsi     # 0x21efe
callq 0x21b0
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
movl $0x2, %esi
callq 0x3330
movq -0x10(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x2320
movq %rax, %rdi
leaq 0x1e926(%rip), %rsi     # 0x21059
callq 0x21b0
movq %rax, %rdi
movq 0x2e886(%rip), %rsi     # 0x30fc8
callq 0x21e0
movq 0x2e88a(%rip), %rdi     # 0x30fd8
leaq 0x1e908(%rip), %rsi     # 0x2105d
callq 0x21b0
movq %rax, %rdi
movq 0x2e864(%rip), %rsi     # 0x30fc8
callq 0x21e0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: npaster[P]gmsh_tools/gmshElement.cpp
// Function: gmsh::Element::print() const
void
Element::print() const
{
   std::cout << "--------------- Element --------------" << std::endl;
   std::cout << "Index: " << _index << std::endl;
   std::cout << "Type_elem: " << _type_elem << std::endl;
   std::cout << "Physical_entities: " << _physical_entities << std::endl;
   std::cout << "ElemTag: " << _elem_tag << std::endl;
   std::cout << "Number of Node: " << _nodes.size() << std::endl;

   for (size_t i = 0; i < _nodes.size(); i++) {
      std::cout << "Node " << i << " " << _nodes[i] << std::endl;
   }

   std::cout << "--------------------------------------" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x2e4ad(%rip), %rdi     # 0x30fd8
leaq 0x1e552(%rip), %rsi     # 0x21084
callq 0x21b0
movq %rax, %rdi
movq 0x2e487(%rip), %rsi     # 0x30fc8
callq 0x21e0
movq 0x2e48b(%rip), %rdi     # 0x30fd8
leaq 0x1e4d4(%rip), %rsi     # 0x21028
callq 0x21b0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x2060
movq %rax, %rdi
movq 0x2e455(%rip), %rsi     # 0x30fc8
callq 0x21e0
movq 0x2e459(%rip), %rdi     # 0x30fd8
leaq 0x1e525(%rip), %rsi     # 0x210ab
callq 0x21b0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x2060
movq %rax, %rdi
movq 0x2e423(%rip), %rsi     # 0x30fc8
callq 0x21e0
movq 0x2e427(%rip), %rdi     # 0x30fd8
leaq 0x1e4ff(%rip), %rsi     # 0x210b7
callq 0x21b0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x2060
movq %rax, %rdi
movq 0x2e3f1(%rip), %rsi     # 0x30fc8
callq 0x21e0
movq 0x2e3f5(%rip), %rdi     # 0x30fd8
leaq 0x1e4e1(%rip), %rsi     # 0x210cb
callq 0x21b0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x2060
movq %rax, %rdi
movq 0x2e3bf(%rip), %rsi     # 0x30fc8
callq 0x21e0
movq 0x2e3c3(%rip), %rdi     # 0x30fd8
leaq 0x1e4b9(%rip), %rsi     # 0x210d5
callq 0x21b0
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x36e0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x2060
movq %rax, %rdi
movq 0x2e384(%rip), %rsi     # 0x30fc8
callq 0x21e0
movq $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x36e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x2cd9
movq 0x2e363(%rip), %rdi     # 0x30fd8
leaq 0x1e46a(%rip), %rsi     # 0x210e6
callq 0x21b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x2060
movq %rax, %rdi
leaq 0x1f267(%rip), %rsi     # 0x21efe
callq 0x21b0
movq -0x20(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0x3700
movq -0x30(%rbp), %rdi
movq (%rax), %rsi
callq 0x2060
movq %rax, %rdi
movq 0x2e305(%rip), %rsi     # 0x30fc8
callq 0x21e0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2c51
movq 0x2e2f8(%rip), %rdi     # 0x30fd8
leaq 0x1e376(%rip), %rsi     # 0x2105d
callq 0x21b0
movq %rax, %rdi
movq 0x2e2d2(%rip), %rsi     # 0x30fc8
callq 0x21e0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: npaster[P]gmsh_tools/gmshMesh.cpp
// Function: gmsh::Gmesh::readGmesh(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void
Gmesh::readGmesh(const std::string name_mesh)
{
   size_t      pos = name_mesh.find(".m");
   std::string ext = name_mesh.substr(pos);

   if (ext == ".mesh") {
      Gmesh::readGmesh_MEDITformat(name_mesh);
   } else if (ext == ".msh") {
      Gmesh::readGmesh_MSHformat(name_mesh);
   } else {
      std::cout << "Unknown file format" << std::endl;
      abort();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0xb0(%rbp)
movq %rdi, %rax
movq -0xb0(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq 0x19597(%rip), %rsi     # 0x21bc4
xorl %eax, %eax
movl %eax, %edx
callq 0x2340
movq -0xa0(%rbp), %rsi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movq $-0x1, %rcx
callq 0x21d0
movq -0x98(%rbp), %rdi
leaq 0x1955d(%rip), %rsi     # 0x21bc7
callq 0xf460
movb %al, -0x89(%rbp)
jmp 0x8677
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x8683
jmp 0x86e0
movq -0xa0(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x20d0
jmp 0x8695
movq -0xa8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5f80
jmp 0x86a7
leaq -0x68(%rbp), %rdi
callq 0x2120
jmp 0x878e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x87a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2120
jmp 0x87a0
leaq 0x198ff(%rip), %rsi     # 0x21fe6
leaq -0x38(%rbp), %rdi
callq 0xf460
movb %al, -0xb1(%rbp)
jmp 0x86f8
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x8704
jmp 0x8756
movq -0xa0(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x20d0
jmp 0x8719
movq -0xa8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x7520
jmp 0x872e
leaq -0x88(%rbp), %rdi
callq 0x2120
jmp 0x878c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2120
jmp 0x87a0
movq 0x2887b(%rip), %rdi     # 0x30fd8
leaq 0x19469(%rip), %rsi     # 0x21bcd
callq 0x21b0
movq %rax, -0xc0(%rbp)
jmp 0x8772
movq -0xc0(%rbp), %rdi
movq 0x28848(%rip), %rsi     # 0x30fc8
callq 0x21e0
jmp 0x8787
callq 0x2110
jmp 0x878e
leaq -0x38(%rbp), %rdi
callq 0x2120
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x2120
movq -0x40(%rbp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)
// File: npaster[P]gmsh_tools/gmshMesh.cpp
// Function: gmsh::Gmesh::writeGmesh(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long) const
void
Gmesh::writeGmesh(const std::string name_mesh, const size_t format) const
{
   if (format == 1) {
      Gmesh::writeGmesh_MEDITformat(name_mesh);
   } else if (format == 2) {
      Gmesh::writeGmesh_MSHformat(name_mesh);
   } else {
      std::cout << "Unknown file format" << std::endl;
      abort();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x1, -0x18(%rbp)
jne 0xc742
movq -0x78(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x20d0
movq -0x70(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x87c0
jmp 0xc71a
leaq -0x38(%rbp), %rdi
callq 0x2120
jmp 0xc7ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2120
jmp 0xc7c3
cmpq $0x2, -0x18(%rbp)
jne 0xc791
movq -0x78(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x20d0
movq -0x70(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0xa000
jmp 0xc76f
leaq -0x68(%rbp), %rdi
callq 0x2120
jmp 0xc7b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2120
jmp 0xc7c3
movq 0x24840(%rip), %rdi     # 0x30fd8
leaq 0x1542e(%rip), %rsi     # 0x21bcd
callq 0x21b0
movq %rax, %rdi
movq 0x2481a(%rip), %rsi     # 0x30fc8
callq 0x21e0
callq 0x2110
jmp 0xc7ba
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x22e0
nopl (%rax)
// File: npaster[P]gmsh_tools/gmshMesh.cpp
// Function: gmsh::Gmesh::convertInDiscontinuousMesh()
void
Gmesh::convertInDiscontinuousMesh()
{
   if (_dim_topology == 1) {
      convertInDiscontinuousMesh1();
   } else if (_dim_topology == 2) {
      convertInDiscontinuousMesh2();
   } else if (_dim_topology == 3) {
      convertInDiscontinuousMesh3();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x1, (%rax)
jne 0xdbd5
movq -0x10(%rbp), %rdi
callq 0xcd60
jmp 0xdc01
movq -0x10(%rbp), %rax
cmpq $0x2, (%rax)
jne 0xdbea
movq -0x10(%rbp), %rdi
callq 0xcfb0
jmp 0xdbff
movq -0x10(%rbp), %rax
cmpq $0x3, (%rax)
jne 0xdbfd
movq -0x10(%rbp), %rdi
callq 0xd3b0
jmp 0xdbff
jmp 0xdc01
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)