LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: BGI-Qingdao[P]ExtractNGSReads/utils/file_writer.cpp
// Function: BGIQD::FILES::FileWriterFactory::GenerateWriterFromFileName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::ostream * FileWriterFactory::GenerateWriterFromFileName( const std::string & file_name )
    {
        std::ostream * ret = NULL;
        if( file_name.rfind(".gz") == file_name.length() - 3 )
        {// gzip file
            ret = (new ogzstream(file_name.c_str()));
        }
        else
        { // treat as txt file now //TODO
            ret = (new std::ofstream(file_name.c_str()));
        }
        if (ret && ! ret->good() )
        {
            delete ret ;
            ret = NULL;
        }
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3407(%rip), %rsi      # 0x14966
movq $-0x1, %rdx
callq 0x5630
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x55b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x3, %rcx
cmpq %rcx, %rax
jne 0x115f8
movl $0x298, %edi            # imm = 0x298
callq 0x53c0
movq %rax, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x51b0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x11720
jmp 0x115b6
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x40(%rbp)
je 0x115d4
movq -0x38(%rbp), %rax
addq $0x188, %rax            # imm = 0x188
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x11647
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x5370
jmp 0x1168c
movl $0x200, %edi            # imm = 0x200
callq 0x53c0
movq %rax, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x51b0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x5440
jmp 0x11626
movq -0x50(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x11647
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x5370
jmp 0x1168c
cmpq $0x0, -0x10(%rbp)
je 0x11682
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x5660
testb $0x1, %al
jne 0x11682
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x1167a
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x5690
nopw %cs:(%rax,%rax)
// File: BGI-Qingdao[P]ExtractNGSReads/utils/file_writer.cpp
// Function: BGIQD::FILES::FileWriterFactory::ResizeBuff(std::ostream&, unsigned long)
void FileWriterFactory::ResizeBuff( std::ostream & ist, size_t size )
    {
        char * buffer = (char *) calloc( sizeof(char) , size );
        if( buffer == 0 )
        {
            std::cerr<<"Fatal buffer calloc failed . System has no more memory ."<<std::endl;
            exit(1);
        }
        (ist.rdbuf())->pubsetbuf(buffer,size);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movl $0x1, %edi
callq 0x5280
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x116f5
movq 0xb920(%rip), %rdi      # 0x1cff0
leaq 0x3293(%rip), %rsi      # 0x1496a
callq 0x53b0
movq %rax, %rdi
movq 0xb8c2(%rip), %rsi      # 0x1cfa8
callq 0x5410
movl $0x1, %edi
callq 0x5480
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x51d0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x5060
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: BGI-Qingdao[P]ExtractNGSReads/utils/seq.cpp
// Function: BGIQD::SEQ::seq::ReverseCompleteSeq[abi:cxx11](int) const
std::string seq::ReverseCompleteSeq(int weight) const
            {
                std::string r_atcgs = seqCompleteReverse(atcgs);
                if( weight < 1 )
                    return r_atcgs ;
                else
                {
                    std::ostringstream ost;
                    int i = 1 ;
                    for( char c : r_atcgs)
                    {
                        ost<<c;
                        if( i % weight == 0 || i == (int)r_atcgs.size() )
                            ost<<'\n';
                        i++ ;
                    }
                    return ost.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)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x124d0
cmpl $0x1, -0x14(%rbp)
jge 0x12346
movq -0x1f8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5230
movl $0x1, -0x3c(%rbp)
jmp 0x12499
leaq -0x1b8(%rbp), %rdi
callq 0x54f0
jmp 0x12354
movl $0x1, -0x1c8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rdi
callq 0x5320
movq %rax, -0x1d8(%rbp)
movq -0x1d0(%rbp), %rdi
callq 0x5220
movq %rax, -0x1e0(%rbp)
leaq -0x1d8(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x12960
testb $0x1, %al
jne 0x123ab
jmp 0x12471
leaq -0x1d8(%rbp), %rdi
callq 0x129a0
movb (%rax), %al
movb %al, -0x1e1(%rbp)
movsbl -0x1e1(%rbp), %esi
leaq -0x1b8(%rbp), %rdi
callq 0x5470
jmp 0x123d4
movl -0x1c8(%rbp), %eax
cltd
idivl -0x14(%rbp)
cmpl $0x0, %edx
je 0x12405
movl -0x1c8(%rbp), %eax
movl %eax, -0x1fc(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x52c0
movq %rax, %rcx
movl -0x1fc(%rbp), %eax
cmpl %ecx, %eax
jne 0x12451
leaq -0x1b8(%rbp), %rdi
movl $0xa, %esi
callq 0x5470
jmp 0x12418
jmp 0x12451
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x124b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x50d0
jmp 0x124b2
movl -0x1c8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c8(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0x129c0
jmp 0x1238f
movq -0x1f8(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x53d0
jmp 0x12486
movl $0x1, -0x3c(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x50d0
leaq -0x38(%rbp), %rdi
callq 0x5250
movq -0x1f0(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x5250
movq -0x1c0(%rbp), %rdi
callq 0x5690
nopw (%rax,%rax)
// File: BGI-Qingdao[P]ExtractNGSReads/utils/seq.cpp
// Function: BGIQD::SEQ::seq::Seq[abi:cxx11](int) const
std::string seq::Seq(int weight ) const
            {
                if( weight < 1 )
                    return atcgs ;
                else
                {
                    std::ostringstream ost;
                    int i = 1 ;
                    for( char c : atcgs)
                    {
                        ost<<c;
                        if( i % weight == 0 || i == (int)atcgs.size() )
                            ost<<'\n';
                        i++ ;
                    }
                    return ost.str();
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1e0(%rbp)
movq %rdi, %rax
movq %rax, -0x1d8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1d0(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x12800
movq -0x1d0(%rbp), %rsi
movq -0x1e0(%rbp), %rdi
callq 0x51c0
jmp 0x12939
leaq -0x190(%rbp), %rdi
callq 0x54f0
movq -0x1d0(%rbp), %rax
movl $0x1, -0x194(%rbp)
movq %rax, -0x1a0(%rbp)
movq -0x1a0(%rbp), %rdi
callq 0x5380
movq %rax, -0x1a8(%rbp)
movq -0x1a0(%rbp), %rdi
callq 0x5710
movq %rax, -0x1b0(%rbp)
leaq -0x1a8(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x129e0
testb $0x1, %al
jne 0x12866
jmp 0x12918
leaq -0x1a8(%rbp), %rdi
callq 0x12a20
movb (%rax), %al
movb %al, -0x1b1(%rbp)
movsbl -0x1b1(%rbp), %esi
leaq -0x190(%rbp), %rdi
callq 0x5470
jmp 0x1288f
movl -0x194(%rbp), %eax
cltd
idivl -0x14(%rbp)
cmpl $0x0, %edx
je 0x128c3
movq -0x1d0(%rbp), %rdi
movl -0x194(%rbp), %eax
movl %eax, -0x1e4(%rbp)
callq 0x52c0
movq %rax, %rcx
movl -0x1e4(%rbp), %eax
cmpl %ecx, %eax
jne 0x128f8
leaq -0x190(%rbp), %rdi
movl $0xa, %esi
callq 0x5470
jmp 0x128d6
jmp 0x128f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x50d0
jmp 0x12949
movl -0x194(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x194(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x12a40
jmp 0x1284a
movq -0x1e0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x53d0
jmp 0x1292d
leaq -0x190(%rbp), %rdi
callq 0x50d0
movq -0x1d8(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1c0(%rbp), %rdi
callq 0x5690
nopw %cs:(%rax,%rax)
nop
// File: BGI-Qingdao[P]ExtractNGSReads/utils/stringtools.cpp
// Function: BGIQD::STRING::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<std::string>  split( const std::string & str , const std::string & spliter ) 
    {
        std::vector<std::string> ret;
        std::string::size_type pos1 = 0;
        std::string::size_type pos2 = str.find(spliter);
        while( pos2 != str.npos )
        {
            auto item = str.substr( pos1 , pos2-pos1 ) ;
            if( ! item.empty() )
                ret.push_back( item );
            pos1 = pos2 + spliter.length() ;
            pos2 = str.find( spliter , pos1 ) ;
        }
        if( pos1 != str.length() )
        {
            ret.push_back(str.substr(pos1));
        }
        return ret ;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xa2c0
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x5740
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x30(%rbp)
je 0x12db7
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
subq %rdx, %rcx
leaq -0x50(%rbp), %rdi
callq 0x53f0
jmp 0x12d23
leaq -0x50(%rbp), %rdi
callq 0x5620
testb $0x1, %al
jne 0x12d6f
movq -0x90(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x13460
jmp 0x12d42
jmp 0x12d6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x12e4e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5250
jmp 0x12e4e
movq -0x30(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rdi
callq 0x55b0
movq %rax, %rcx
movq -0x98(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x5740
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5250
jmp 0x12cfe
movq -0x28(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x55b0
movq %rax, %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
je 0x12e28
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x80(%rbp), %rdi
movq $-0x1, %rcx
callq 0x53f0
jmp 0x12df4
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xa450
jmp 0x12e06
leaq -0x80(%rbp), %rdi
callq 0x5250
jmp 0x12e28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x5250
jmp 0x12e4e
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x12e3e
movq -0x90(%rbp), %rdi
callq 0xb5f0
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0xb5f0
movq -0x58(%rbp), %rdi
callq 0x5690
nopw %cs:(%rax,%rax)
// File: BGI-Qingdao[P]ExtractNGSReads/utils/stringtools.cpp
// Function: BGIQD::STRING::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const&)
std::vector<std::string>  split( const std::string & str , const char& spliter ) 
    {
        std::vector<std::string> ret;
        std::string::size_type pos1 = 0;
        std::string::size_type pos2 = str.find(spliter);
        while( pos2 != str.npos )
        {
            auto item = str.substr( pos1 , pos2-pos1 ) ;
            if( ! item.empty() )
                ret.push_back( item );
            pos1 = pos2 + 1 ;
            pos2 = str.find( spliter , pos1 ) ;
        }
        if( pos1 != str.length() )
        {
            ret.push_back(str.substr(pos1));
        }
        return ret ;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xa2c0
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
movsbl (%rax), %esi
callq 0x54c0
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x30(%rbp)
je 0x12f66
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
subq %rdx, %rcx
leaq -0x50(%rbp), %rdi
callq 0x53f0
jmp 0x12ee6
leaq -0x50(%rbp), %rdi
callq 0x5620
testb $0x1, %al
jne 0x12f32
movq -0x90(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x13460
jmp 0x12f05
jmp 0x12f32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x12ffd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5250
jmp 0x12ffd
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movb (%rax), %al
movq -0x28(%rbp), %rdx
movsbl %al, %esi
callq 0x54c0
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5250
jmp 0x12ec1
movq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rdi
callq 0x55b0
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
je 0x12fd7
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x80(%rbp), %rdi
movq $-0x1, %rcx
callq 0x53f0
jmp 0x12fa3
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xa450
jmp 0x12fb5
leaq -0x80(%rbp), %rdi
callq 0x5250
jmp 0x12fd7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x5250
jmp 0x12ffd
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x12fed
movq -0x90(%rbp), %rdi
callq 0xb5f0
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0xb5f0
movq -0x58(%rbp), %rdi
callq 0x5690
nopw %cs:(%rax,%rax)
// File: BGI-Qingdao[P]ExtractNGSReads/utils/stringtools.cpp
// Function: BGIQD::STRING::replace_all(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void replace_all( std::string &strBig,
            const std::string &strsrc,
            const std::string &strdst )
    {
        std::string::size_type pos = 0;
        std::string::size_type srclen = strsrc.size();
        std::string::size_type dstlen = strdst.size();

        while( (pos=strBig.find(strsrc, pos)) != std::string::npos )
        {
            strBig.replace( pos, srclen, strdst );
            pos += dstlen;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x52c0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x52c0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5740
movq %rax, -0x20(%rbp)
cmpq $-0x1, %rax
je 0x133d4
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x5170
movq -0x30(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x13396
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: BGI-Qingdao[P]ExtractNGSReads/utils/stringtools.cpp
// Function: BGIQD::STRING::IsNum(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool IsNum(const std::string & str)
    {
        for( char i : str )
        {
            if( ! std::isdigit(i) )
                return false ;
        }
        return true ;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5380
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5710
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x129e0
testb $0x1, %al
jne 0x13421
jmp 0x13450
leaq -0x20(%rbp), %rdi
callq 0x12a20
movb (%rax), %al
movb %al, -0x29(%rbp)
movsbl -0x29(%rbp), %edi
callq 0x5360
cmpl $0x0, %eax
jne 0x13443
movb $0x0, -0x1(%rbp)
jmp 0x13454
jmp 0x13445
leaq -0x20(%rbp), %rdi
callq 0x12a40
jmp 0x1340e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: kdungs[P]codecon/src/rooms.cc
// Function: query(std::vector<Room, std::allocator<Room>> const&, unsigned int, unsigned int)
auto query(const std::vector<Room>& rooms, unsigned slot, unsigned nslots)
    -> std::vector<std::size_t> {
  auto roomsAvailable = std::vector<std::size_t>{};
  for (auto i = 0ul; i < rooms.size(); ++i) {
    if (rooms[i].available(slot, nslots)) {
      roomsAvailable.emplace_back(i);
    }
  }
  return roomsAvailable;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x20b0
movq -0x40(%rbp), %rdi
callq 0x2b40
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2b60
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x23e8
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2b80
movq %rax, %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x2ba0
testb $0x1, %al
jne 0x23b0
jmp 0x23d8
movq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2c50
jmp 0x23bf
jmp 0x23d8
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x2cd0
jmp 0x2405
jmp 0x23da
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2372
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x23fb
movq -0x40(%rbp), %rdi
callq 0x2cd0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x21d0
nop
// File: kdungs[P]codecon/src/rooms.cc
// Function: splitAtDash(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
auto splitAtDash(const std::string& str) -> std::vector<unsigned> {
  std::vector<unsigned> result;
  std::stringstream ss{str};
  std::string tmp;
  while (getline(ss, tmp, '-')) {
    result.push_back(static_cast<unsigned>(std::stoul(tmp)));
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x1f0(%rbp)
movq %rdi, %rax
movq %rax, -0x1e8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x2d30
movq -0x10(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x2d50
movl %eax, -0x1d8(%rbp)
jmp 0x245f
movl -0x1d8(%rbp), %edx
movq -0x1e0(%rbp), %rsi
leaq -0x1a0(%rbp), %rdi
callq 0x21a0
jmp 0x247a
leaq -0x1d0(%rbp), %rdi
callq 0x2170
leaq -0x1a0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
movl $0x2d, %edx
callq 0x21e0
movq %rax, -0x1f8(%rbp)
jmp 0x24a7
movq -0x1f8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2160
movb %al, -0x1f9(%rbp)
jmp 0x24c5
movb -0x1f9(%rbp), %al
testb $0x1, %al
jne 0x24d4
jmp 0x2559
xorl %eax, %eax
movl %eax, %esi
leaq -0x1d0(%rbp), %rdi
movl $0xa, %edx
callq 0x2da0
movq %rax, -0x208(%rbp)
jmp 0x24f2
movq -0x1f0(%rbp), %rdi
movq -0x208(%rbp), %rax
movl %eax, -0x1d4(%rbp)
leaq -0x1d4(%rbp), %rsi
callq 0x2d70
jmp 0x2514
jmp 0x2486
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x2597
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x20d0
leaq -0x1a0(%rbp), %rdi
callq 0x20f0
jmp 0x2597
movb $0x1, -0x11(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x20d0
leaq -0x1a0(%rbp), %rdi
callq 0x20f0
testb $0x1, -0x11(%rbp)
jne 0x2587
movq -0x1f0(%rbp), %rdi
callq 0x2de0
movq -0x1e8(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x1f0(%rbp), %rdi
callq 0x2de0
movq -0x1a8(%rbp), %rdi
callq 0x21d0
nop
// File: kdungs[P]codecon/src/rooms.cc
// Function: Room::available(unsigned int, unsigned int) const
auto available(unsigned slot, unsigned nslots) const noexcept -> bool {
    assert(slot + nslots < NUM_SLOTS);
    return std::all_of(std::begin(slots_) + slot,
                       std::begin(slots_) + slot + nslots,
                       [](bool x) { return !x; });
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, %eax
cmpq $0x20, %rax
jae 0x2bca
jmp 0x2be9
leaq 0x3481(%rip), %rdi      # 0x6052
leaq 0x3494(%rip), %rsi      # 0x606c
movl $0x1a, %edx
leaq 0x3495(%rip), %rcx      # 0x6079
callq 0x20e0
movq -0x20(%rbp), %rdi
callq 0x32d0
movq %rax, -0x28(%rbp)
jmp 0x2bf8
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
callq 0x32d0
movq %rax, -0x30(%rbp)
jmp 0x2c15
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0xc(%rbp), %eax
addq %rax, %rsi
movl -0x10(%rbp), %eax
addq %rax, %rsi
callq 0x3290
movb %al, -0x39(%rbp)
jmp 0x2c33
movb -0x39(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x32f0
nopw %cs:(%rax,%rax)
// File: kdungs[P]codecon/src/rooms.cc
// Function: void printWithSpace<unsigned long>(std::vector<unsigned long, std::allocator<unsigned long>> const&)
auto printWithSpace(const std::vector<T>& xs) -> void {
  assert(!xs.empty());
  auto it = std::begin(xs);
  std::cout << *it;
  ++it;
  for (; it != std::end(xs); ++it) {
    std::cout << " " << *it;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2f30
xorb $-0x1, %al
testb $0x1, %al
jne 0x2fed
jmp 0x2fef
jmp 0x300e
leaq 0x3153(%rip), %rdi      # 0x6149
leaq 0x306f(%rip), %rsi      # 0x606c
movl $0x3b, %edx
leaq 0x314c(%rip), %rcx      # 0x6155
callq 0x20e0
movq -0x8(%rbp), %rdi
callq 0x5900
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x5930
movq (%rax), %rsi
movq 0x6f9a(%rip), %rdi      # 0x9fc8
callq 0x2050
leaq -0x10(%rbp), %rdi
callq 0x5950
movq -0x8(%rbp), %rdi
callq 0x59b0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x5970
testb $0x1, %al
jne 0x305c
jmp 0x3093
movq 0x6f65(%rip), %rdi      # 0x9fc8
leaq 0x312b(%rip), %rsi      # 0x6195
callq 0x2120
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x5930
movq -0x20(%rbp), %rdi
movq (%rax), %rsi
callq 0x2050
leaq -0x10(%rbp), %rdi
callq 0x5950
jmp 0x303c
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: kdungs[P]codecon/src/rooms.cc
// Function: Room::book(unsigned int, unsigned int)
auto book(unsigned start, unsigned nslots) -> bool {
    assert(start + nslots <= NUM_SLOTS);
    if (std::any_of(std::begin(slots_) + start,
                    std::begin(slots_) + start + nslots,
                    [](bool x) { return x; })) {
      return false;
    }

    std::fill_n(std::begin(slots_) + start, nslots, true);
    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, %eax
cmpq $0x20, %rax
ja 0x30ea
jmp 0x3109
leaq 0x2fc5(%rip), %rdi      # 0x60b6
leaq 0x2f74(%rip), %rsi      # 0x606c
movl $0xe, %edx
leaq 0x2fce(%rip), %rcx      # 0x60d2
callq 0x20e0
movq -0x28(%rbp), %rdi
callq 0x3940
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
callq 0x3940
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %eax
addq %rax, %rsi
movl -0x18(%rbp), %eax
addq %rax, %rsi
callq 0x3910
testb $0x1, %al
jne 0x3143
jmp 0x3149
movb $0x0, -0x1(%rbp)
jmp 0x316f
movq -0x28(%rbp), %rdi
callq 0x3940
movq %rax, %rdi
movl -0x14(%rbp), %eax
addq %rax, %rdi
movl -0x18(%rbp), %esi
movb $0x1, -0x1a(%rbp)
leaq -0x1a(%rbp), %rdx
callq 0x3960
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: vividvilla[P]hackerrank/src/quicksort2.cpp
// Function: main
int main() {
    int n, x;
    vector <int> v;

    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> x;
        v.push_back(x);
    }

    quickSort(v);

    return 0;
}

// Assembly:
subq $0x38, %rsp
movl $0x0, 0x34(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x16f0
movq 0x59b3(%rip), %rdi      # 0x6fe0
leaq 0x30(%rsp), %rsi
callq 0x1070
jmp 0x1639
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x30(%rsp), %eax
jge 0x1694
movq 0x5990(%rip), %rdi      # 0x6fe0
leaq 0x2c(%rsp), %rsi
callq 0x1070
jmp 0x165c
leaq 0x10(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x1700
jmp 0x166d
jmp 0x166f
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x1640
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x8(%rsp)
movl %eax, 0x4(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x18f0
jmp 0x16bb
leaq 0x10(%rsp), %rdi
callq 0x15d0
jmp 0x16a0
movl $0x0, 0x34(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x18f0
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
movq 0x8(%rsp), %rdi
callq 0x1130
nopw %cs:(%rax,%rax)
nop
// File: grogers0[P]dots_and_boxes/BruteForce.cpp
// Function: main
int main(int argc, char **argv)
{
    if (argc < 3)
        usage();

    int width = atoi(argv[1]);
    int height = atoi(argv[2]);

    Board board(width, height);
    brute_force(board);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
jge 0x9314
callq 0x9390
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x22d0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x22d0
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
leaq -0x60(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x2490
movq -0x78(%rbp), %rdi
callq 0x8ea0
jmp 0x9352
leaq -0x60(%rbp), %rdi
callq 0x4f20
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4f20
movq -0x68(%rbp), %rdi
callq 0x2320
nopw %cs:(%rax,%rax)
// File: grogers0[P]dots_and_boxes/./Board.h
// Function: Edge::operator<(Edge) const
bool operator<(Edge edge) const
    {
        if (dir < edge.dir) return true;
        if (edge.dir < dir) return false;
        if (x < edge.x) return true;
        if (edge.x < x) return false;
        if (y < edge.y) return true;
        if (edge.y < y) return false;
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movw (%rax), %ax
andw $0x1, %ax
movzwl %ax, %eax
movw -0x8(%rbp), %cx
andw $0x1, %cx
movzwl %cx, %ecx
cmpl %ecx, %eax
jge 0xa035
movb $0x1, -0x1(%rbp)
jmp 0xa0f3
movq -0x18(%rbp), %rcx
movw -0x8(%rbp), %ax
andw $0x1, %ax
movzwl %ax, %eax
movw (%rcx), %cx
andw $0x1, %cx
movzwl %cx, %ecx
cmpl %ecx, %eax
jge 0xa05b
movb $0x0, -0x1(%rbp)
jmp 0xa0f3
movq -0x18(%rbp), %rax
movw (%rax), %ax
shlw $0x8, %ax
sarw $0x9, %ax
cwtl
movw -0x8(%rbp), %cx
shlw $0x8, %cx
sarw $0x9, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0xa084
movb $0x1, -0x1(%rbp)
jmp 0xa0f3
movq -0x18(%rbp), %rcx
movw -0x8(%rbp), %ax
shlw $0x8, %ax
sarw $0x9, %ax
cwtl
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x9, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0xa0ad
movb $0x0, -0x1(%rbp)
jmp 0xa0f3
movq -0x18(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
movw -0x8(%rbp), %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0xa0ce
movb $0x1, -0x1(%rbp)
jmp 0xa0f3
movq -0x18(%rbp), %rcx
movw -0x8(%rbp), %ax
sarw $0x8, %ax
cwtl
movw (%rcx), %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0xa0ef
movb $0x0, -0x1(%rbp)
jmp 0xa0f3
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: LiuYinCarl[P]headerFileAnalysis/headerFileAnalysis.cpp
// Function: Node::Node(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Node::Node(uint32_t id, const std::string& name) {
  assert(id > 0);
  assert(name.size() > 0);
  node_id = id;
  node_name = name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x6650
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x30(%rbp)
callq 0x8cf0
cmpl $0x0, -0xc(%rbp)
jbe 0x6a51
jmp 0x6a70
leaq 0x3c77c(%rip), %rdi     # 0x431d4
leaq 0x3c77c(%rip), %rsi     # 0x431db
movl $0x13, %edx
leaq 0x3c787(%rip), %rcx     # 0x431f2
callq 0x6370
movq -0x18(%rbp), %rdi
callq 0x63a0
cmpq $0x0, %rax
jbe 0x6a81
jmp 0x6aa0
leaq 0x3c8bb(%rip), %rdi     # 0x43343
leaq 0x3c74c(%rip), %rsi     # 0x431db
movl $0x14, %edx
leaq 0x3c757(%rip), %rcx     # 0x431f2
callq 0x6370
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
movq -0x18(%rbp), %rsi
addq $0x8, %rdi
callq 0x6060
jmp 0x6ab8
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x8d10
movq -0x40(%rbp), %rdi
callq 0x6310
movq -0x20(%rbp), %rdi
callq 0x6780
nopw %cs:(%rax,%rax)
// File: LiuYinCarl[P]headerFileAnalysis/headerFileAnalysis.cpp
// Function: Node::set_node_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Node::set_node_name(const std::string& name) {
  if (name.size() == 0 || name.size() > 100) {
    return false;
  }
  node_name = name;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x63a0
cmpq $0x0, %rax
je 0x6b66
movq -0x18(%rbp), %rdi
callq 0x63a0
cmpq $0x64, %rax
jbe 0x6b6c
movb $0x0, -0x1(%rbp)
jmp 0x6b81
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rdi
callq 0x6060
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: LiuYinCarl[P]headerFileAnalysis/headerFileAnalysis.cpp
// Function: Node::add_child_node(unsigned int)
bool Node::add_child_node(uint32_t id) {
  assert(id > 0);
  // this check is necessary, otherwise there will have 'fake' circle include.
  // for example, Meta's folly code base has a Windows.h,
  // and in this file include another Windows.h which is the Header file of Windows System.
  if (id == node_id) return false;

  child_nodes.push_back(id);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jbe 0x6c3f
jmp 0x6c5e
leaq 0x3c58e(%rip), %rdi     # 0x431d4
leaq 0x3c58e(%rip), %rsi     # 0x431db
movl $0x34, %edx
leaq 0x3c5e4(%rip), %rcx     # 0x4323d
callq 0x6370
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jne 0x6c6f
movb $0x0, -0x1(%rbp)
jmp 0x6c84
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
leaq -0x14(%rbp), %rsi
callq 0x8d90
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: LiuYinCarl[P]headerFileAnalysis/headerFileAnalysis.cpp
// Function: Graph::get_node_by_id(unsigned int)
Node* Graph::get_node_by_id(uint32_t id) {
  assert(id > 0);
  auto node_iter = node_map.find(id);
  if (node_iter == node_map.end())
    return nullptr;
  else
    return node_iter->second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
jbe 0x70bf
jmp 0x70de
leaq 0x3c10e(%rip), %rdi     # 0x431d4
leaq 0x3c10e(%rip), %rsi     # 0x431db
movl $0x65, %edx
leaq 0x3c1cc(%rip), %rcx     # 0x432a5
callq 0x6370
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
leaq -0x14(%rbp), %rsi
callq 0x8f40
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x8fa0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8f70
testb $0x1, %al
jne 0x7117
jmp 0x7121
movq $0x0, -0x8(%rbp)
jmp 0x7132
leaq -0x20(%rbp), %rdi
callq 0x9160
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: LiuYinCarl[P]headerFileAnalysis/headerFileAnalysis.cpp
// Function: Graph::get_node_by_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Node* Graph::get_node_by_name(const std::string& name) {
  assert(name.size() > 0);
  auto node_iter = node_name_map.find(name);
  if (node_iter == node_name_map.end())
    return nullptr;
  else
    return node_iter->second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x63a0
cmpq $0x0, %rax
jbe 0x7169
jmp 0x7188
leaq 0x3c1d3(%rip), %rdi     # 0x43343
leaq 0x3c064(%rip), %rsi     # 0x431db
movl $0x6e, %edx
leaq 0x3c148(%rip), %rcx     # 0x432cb
callq 0x6370
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
callq 0x9180
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x38, %rdi
callq 0x91e0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x91b0
testb $0x1, %al
jne 0x71c1
jmp 0x71cb
movq $0x0, -0x8(%rbp)
jmp 0x71dc
leaq -0x20(%rbp), %rdi
callq 0x9210
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: LiuYinCarl[P]headerFileAnalysis/headerFileAnalysis.cpp
// Function: Graph::add_record(Node*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool Graph::add_record(Node* node, std::string& parent_name) {
  assert(node != nullptr);
  assert(parent_name.size() > 0);

  // 1. find parent node. if parent node not exist, create it
  Node* parent_node = get_node_by_name(parent_name);
  if (parent_node == nullptr) {
    parent_node = make_node(parent_name);
    add_node(parent_node);
  }

  // 2. insert node into it's parent node
  parent_node->add_child_node(node->get_node_id());

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7215
jmp 0x7234
leaq 0x3c0e2(%rip), %rdi     # 0x432fe
leaq 0x3bfb8(%rip), %rsi     # 0x431db
movl $0x77, %edx
leaq 0x3c0df(%rip), %rcx     # 0x4330e
callq 0x6370
movq -0x18(%rbp), %rdi
callq 0x63a0
cmpq $0x0, %rax
jbe 0x7245
jmp 0x7264
leaq 0x3c0f0(%rip), %rdi     # 0x4333c
leaq 0x3bf88(%rip), %rsi     # 0x431db
movl $0x78, %edx
leaq 0x3c0af(%rip), %rcx     # 0x4330e
callq 0x6370
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7140
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7296
movq -0x18(%rbp), %rdi
callq 0x72c0
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x6d90
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6c10
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x6c20
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: LiuYinCarl[P]headerFileAnalysis/./headerFileAnalysis.h
// Function: make_node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static Node* make_node(const std::string& name) {
  assert(name != "");
  uint32_t id = gen_id();
  Node* node = new Node(id, name);
  return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3c1ad(%rip), %rsi     # 0x43484
callq 0xb3c0
testb $0x1, %al
jne 0x72e2
jmp 0x72e4
jmp 0x7303
leaq 0x3c316(%rip), %rdi     # 0x43601
leaq 0x3c31a(%rip), %rsi     # 0x4360c
movl $0x3e, %edx
leaq 0x3c325(%rip), %rcx     # 0x43623
callq 0x6370
callq 0x8c20
movl %eax, -0xc(%rbp)
movl $0x40, %edi
callq 0x6490
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rdx
callq 0x6a10
jmp 0x732d
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x40, %esi
callq 0x64a0
movq -0x20(%rbp), %rdi
callq 0x6780
nopw %cs:(%rax,%rax)
// File: LiuYinCarl[P]headerFileAnalysis/headerFileAnalysis.cpp
// Function: Graph::print_circle(std::vector<unsigned int, std::allocator<unsigned int>>&)
void Graph::print_circle(std::vector<uint32_t>& circle_link) {
  for (int i = 0; i < circle_link.size(); i++) {
    uint32_t node_id = circle_link.at(i);
    Node* node = get_node_by_id(node_id);
    if (i == 0) {
      std::cout << node->get_node_name();
    } else {
      std::cout << " -> " << node->get_node_name();
    }
  }
  std::cout << std::endl << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8e00
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x742a
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x9230
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
callq 0x70a0
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x73ee
movq -0x20(%rbp), %rdi
callq 0x6b90
movq %rax, %rsi
movq 0x5cbd1(%rip), %rdi     # 0x63fb8
callq 0x6440
jmp 0x741a
movq 0x5cbc3(%rip), %rdi     # 0x63fb8
leaq 0x3bf57(%rip), %rsi     # 0x43353
callq 0x6470
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6b90
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x6440
jmp 0x741c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x738f
movq 0x5cb87(%rip), %rdi     # 0x63fb8
movq 0x5cb58(%rip), %rsi     # 0x63f90
callq 0x64e0
movq %rax, %rdi
movq 0x5cb49(%rip), %rsi     # 0x63f90
callq 0x64e0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: LiuYinCarl[P]headerFileAnalysis/headerFileAnalysis.cpp
// Function: Graph::check_circle()
void Graph::check_circle() {
  std::vector<uint32_t> circle_link;
  for (auto& item : node_map) {
    int node_id = item.first;
    Node* node = item.second;
    check_circle_dfs(node, circle_link);
    visited.insert(node_id);
    visiting.clear();
    assert(circle_link.size() == 0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x8cf0
movq -0x78(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x9490
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8fa0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x94c0
testb $0x1, %al
jne 0x776c
jmp 0x783c
leaq -0x30(%rbp), %rdi
callq 0x94f0
movq -0x78(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x7460
jmp 0x77a1
movq -0x78(%rbp), %rdi
addq $0x68, %rdi
movl -0x44(%rbp), %eax
movl %eax, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x9270
movb %dl, -0x81(%rbp)
movq %rax, -0x80(%rbp)
jmp 0x77c4
movq -0x78(%rbp), %rdi
movb -0x81(%rbp), %al
movq -0x80(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movb %al, -0x68(%rbp)
addq $0x98, %rdi
callq 0x9510
leaq -0x20(%rbp), %rdi
callq 0x8e00
cmpq $0x0, %rax
jne 0x77f6
jmp 0x782c
leaq 0x3bbcf(%rip), %rdi     # 0x433cc
leaq 0x3b9d7(%rip), %rsi     # 0x431db
movl $0xb7, %edx
leaq 0x3bbd4(%rip), %rcx     # 0x433e4
callq 0x6370
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x8d10
jmp 0x784e
jmp 0x782e
leaq -0x30(%rbp), %rdi
callq 0x9530
jmp 0x7756
leaq -0x20(%rbp), %rdi
callq 0x8d10
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x6780
nopw (%rax,%rax)
// File: LiuYinCarl[P]headerFileAnalysis/headerFileAnalysis.cpp
// Function: WalkMan::is_source_code(std::filesystem::__cxx11::path)
bool WalkMan::is_source_code(fs::path extension) {
  const char* ext = extension.c_str();
  if (strcmp(ext, ".h") == 0 ||
      strcmp(ext, ".c") == 0 ||
      strcmp(ext, ".cpp") == 0 ||
      strcmp(ext, ".hpp") == 0) {
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
callq 0x97f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x3b9c1(%rip), %rsi     # 0x43620
callq 0x6660
cmpl $0x0, %eax
je 0x7ca8
movq -0x20(%rbp), %rdi
leaq 0x3b81f(%rip), %rsi     # 0x43493
callq 0x6660
cmpl $0x0, %eax
je 0x7ca8
movq -0x20(%rbp), %rdi
leaq 0x3b564(%rip), %rsi     # 0x431ed
callq 0x6660
cmpl $0x0, %eax
je 0x7ca8
movq -0x20(%rbp), %rdi
leaq 0x3b7f8(%rip), %rsi     # 0x43496
callq 0x6660
cmpl $0x0, %eax
jne 0x7cae
movb $0x1, -0x1(%rbp)
jmp 0x7cb2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: LiuYinCarl[P]headerFileAnalysis/headerFileAnalysis.cpp
// Function: WalkMan::is_header_file(std::filesystem::__cxx11::path)
bool WalkMan::is_header_file(fs::path extension) {
  const char* ext = extension.c_str();
  if (strcmp(ext, ".h") == 0 || strcmp(ext, ".hpp") == 0) {
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
callq 0x97f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x3b931(%rip), %rsi     # 0x43620
callq 0x6660
cmpl $0x0, %eax
je 0x7d0e
movq -0x20(%rbp), %rdi
leaq 0x3b792(%rip), %rsi     # 0x43496
callq 0x6660
cmpl $0x0, %eax
jne 0x7d14
movb $0x1, -0x1(%rbp)
jmp 0x7d18
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: LiuYinCarl[P]headerFileAnalysis/headerFileAnalysis.cpp
// Function: WalkMan::analysis_file()
void WalkMan::analysis_file() {
  // 读取一个文件然后分析出头文件引用
  for (auto& path : source_file_paths) {
    // vector 第一个元素是源文件的名字，其他元素是这个源文件引用的头文件
    std::vector<std::string> include_info = get_include_lines(path);
    assert(include_info.size() > 0);
    include_infos.push_back(include_info);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0xf0, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9c10
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9c40
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9c70
testb $0x1, %al
jne 0x880e
jmp 0x88a0
leaq -0x18(%rbp), %rdi
callq 0x9cb0
movq -0x58(%rbp), %rsi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x81d0
leaq -0x40(%rbp), %rdi
callq 0xa440
cmpq $0x0, %rax
jbe 0x883d
jmp 0x885c
leaq 0x3ace3(%rip), %rdi     # 0x43527
leaq 0x3a990(%rip), %rsi     # 0x431db
movl $0x133, %edx            # imm = 0x133
leaq 0x3ace8(%rip), %rcx     # 0x4353f
callq 0x6370
movq -0x58(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
leaq -0x40(%rbp), %rsi
callq 0xa4c0
jmp 0x8872
leaq -0x40(%rbp), %rdi
callq 0xa460
leaq -0x18(%rbp), %rdi
callq 0x9ea0
jmp 0x87f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa460
jmp 0x88a6
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x6780
nop
// File: LiuYinCarl[P]headerFileAnalysis/headerFileAnalysis.cpp
// Function: WalkMan::build_graph()
void WalkMan::build_graph() {
  for (std::vector<std::string>& include_info : include_infos) {
    // 至少要包含源文件自己的文件名
    assert(include_info.size() >= 1);
    // 1. 添加自身节点
    Node* self_node;
    self_node = g.get_node_by_name(include_info.at(0));
    if (self_node == nullptr) {
      self_node = make_node(include_info.at(0));
      g.add_node(self_node);
    }
    // 2. 添加引用关系
    for (int n = include_info.size(), i = 1; i < n; ++i) {
      g.add_record(self_node, include_info.at(i));
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x138, %rax            # imm = 0x138
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa530
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa560
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xa590
testb $0x1, %al
jne 0x88fe
jmp 0x89e0
leaq -0x18(%rbp), %rdi
callq 0xa5d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa440
cmpq $0x1, %rax
jb 0x891c
jmp 0x893b
leaq 0x3ac3a(%rip), %rdi     # 0x4355d
leaq 0x3a8b1(%rip), %rsi     # 0x431db
movl $0x13b, %edx            # imm = 0x13B
leaq 0x3ac40(%rip), %rcx     # 0x43576
callq 0x6370
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa5f0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x7140
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x8985
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa5f0
movq %rax, %rdi
callq 0x72c0
movq -0x40(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x6d90
movq -0x28(%rbp), %rdi
callq 0xa440
movl %eax, -0x34(%rbp)
movl $0x1, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x89d0
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x38(%rbp), %rsi
callq 0xa5f0
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x71f0
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x8998
jmp 0x89d2
leaq -0x18(%rbp), %rdi
callq 0xa630
jmp 0x88e8
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: LiuYinCarl[P]headerFileAnalysis/headerFileAnalysis.cpp
// Function: WalkMan::start()
void WalkMan::start() {
  walk_dir();
  init_headers();
  analysis_file();
  build_graph();

  g.check_circle();
  g.gen_dot_file();

  std::cout << "source files number: " << source_file_paths.size() << std::endl;
  std::cout << "header files number: " << headers.size() << std::endl;
  std::cout << "graph  node  number: " << g.get_node_count() << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x7d30
movq -0x18(%rbp), %rdi
callq 0x8040
movq -0x18(%rbp), %rdi
callq 0x87c0
movq -0x18(%rbp), %rdi
callq 0x88b0
movq -0x18(%rbp), %rdi
callq 0x7710
movq -0x18(%rbp), %rdi
callq 0x7860
movq 0x5b57b(%rip), %rdi     # 0x63fb8
leaq 0x3ab4e(%rip), %rsi     # 0x43592
callq 0x6470
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0xf0, %rdi
callq 0xa650
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x60d0
movq %rax, %rdi
movq 0x5b51d(%rip), %rsi     # 0x63f90
callq 0x64e0
movq 0x5b539(%rip), %rdi     # 0x63fb8
leaq 0x3ab22(%rip), %rsi     # 0x435a8
callq 0x6470
movq -0x18(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x108, %rdi            # imm = 0x108
callq 0xa680
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x60d0
movq %rax, %rdi
movq 0x5b4db(%rip), %rsi     # 0x63f90
callq 0x64e0
movq 0x5b4f7(%rip), %rdi     # 0x63fb8
leaq 0x3aaf6(%rip), %rsi     # 0x435be
callq 0x6470
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x6d80
movq -0x10(%rbp), %rdi
movl %eax, %esi
callq 0x6640
movq %rax, %rdi
movq 0x5b4a1(%rip), %rsi     # 0x63f90
callq 0x64e0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)