LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/BGI-Qingdao[P]ExtractNGSReads/./utils/fastq.h
// Function: BGIQD::FASTQ::stLFRHeader::operator=(BGIQD::FASTQ::stLFRHeader const&)
stLFRHeader & operator = ( const stLFRHeader & a ) {
                if( &a != this )
                {
                    type = a.type ;
                    readIndex  = a.readIndex ;
                    barcode_num = a.barcode_num ;
                    barcode_str = a.barcode_str ;
                    readName = a.readName ;
                }
                return *this ;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rdi, %rsi
je 0x74f5
movq %rsi, %r14
movl (%rsi), %eax
movl %eax, (%rbx)
movl 0x4(%rsi), %eax
movl %eax, 0x4(%rbx)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rbx)
addq $0x10, %rsi
leaq 0x10(%rbx), %rdi
callq 0x4160
addq $0x30, %r14
leaq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x4160
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/BGI-Qingdao[P]ExtractNGSReads/./utils/fastq.h
// Function: BGIQD::FASTQ::stLFRHeader::stLFRHeader(BGIQD::FASTQ::stLFRHeader const&)
stLFRHeader(const stLFRHeader & a) {
                type = a.type ;
                readIndex  = a.readIndex ;
                barcode_num = a.barcode_num ;
                barcode_str = a.barcode_str ;
                readName = a.readName ;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %r12
movq %r12, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movb %al, 0x20(%rdi)
leaq 0x30(%rdi), %r15
leaq 0x40(%rdi), %r13
movq %r13, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movb %al, 0x40(%rdi)
movl (%rsi), %eax
movl %eax, (%rdi)
movl 0x4(%rsi), %eax
movl %eax, 0x4(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x4160
addq $0x30, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x4160
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x7cc7
callq 0x4240
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x7cd4
callq 0x4240
movq %r14, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O3/BGI-Qingdao[P]ExtractNGSReads/utils/fastq.cpp
// Function: BGIQD::FASTQ::stLFRHeader::Head[abi:cxx11]() const
std::string stLFRHeader::Head() const 
        {
            assert(type != Unknow );
            std::ostringstream ost ;
            ost<<'@'<<readName<<'#'<<barcode_str;
            if( type == readName_barcodeStr_index )
                ost<<'/'<<readIndex;
            if( type == readName_barcodeStr_index_barcodeNum )
                ost<<'/'<<readIndex<<'\t'<<barcode_num;
            return ost.str();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
cmpl $0x0, (%rsi)
je 0x89c5
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x198(%rbp), %r15
movq %r15, %rdi
callq 0x4330
leaq -0x19(%rbp), %rsi
movb $0x40, (%rsi)
movl $0x1, %edx
movq %r15, %rdi
callq 0x42d0
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq %rax, %rdi
callq 0x42d0
leaq -0x19(%rbp), %rsi
movb $0x23, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x42d0
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rax, %rdi
callq 0x42d0
movl (%r14), %eax
cmpl $0x2, %eax
jne 0x893d
leaq -0x19(%rbp), %rsi
movb $0x2f, (%rsi)
leaq -0x198(%rbp), %rdi
movl $0x1, %edx
callq 0x42d0
movl 0x4(%r14), %esi
movq %rax, %rdi
callq 0x4430
movl (%r14), %eax
cmpl $0x3, %eax
jne 0x8986
leaq -0x19(%rbp), %rsi
movb $0x2f, (%rsi)
leaq -0x198(%rbp), %rdi
movl $0x1, %edx
callq 0x42d0
movl 0x4(%r14), %esi
movq %rax, %rdi
callq 0x4430
leaq -0x19(%rbp), %rsi
movb $0x9, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x42d0
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x4430
leaq -0x190(%rbp), %rsi
movq %rbx, %rdi
callq 0x43d0
movq 0x7634(%rip), %rsi      # 0xffd0
leaq -0x198(%rbp), %rdi
callq 0x4150
leaq -0x128(%rbp), %rdi
callq 0x40d0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ecd(%rip), %rdi      # 0xb899
leaq 0x2e46(%rip), %rsi      # 0xb819
leaq 0x2ece(%rip), %rcx      # 0xb8a8
movl $0x34, %edx
callq 0x4190
movq %rax, %rbx
movq 0x75e2(%rip), %rsi      # 0xffd0
leaq -0x198(%rbp), %rdi
callq 0x4150
leaq -0x128(%rbp), %rdi
callq 0x40d0
movq %rbx, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O3/BGI-Qingdao[P]ExtractNGSReads/utils/fastq.cpp
// Function: BGIQD::FASTQ::Id_Desc_Head::Init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Id_Desc_Head::Init( const std::string &line )
        {
            Reset() ;
            bool turn = false ;
            assert(line.size() > 1);
            assert(line[0] == '@');
            for( int i = 1 ; i < (int)line.size() ; i++ )
            {
                if( !turn  )
                {
                    if( ! std::isblank(line[i]) )
                        Id += line[i] ;
                    else 
                        turn = true ;
                }
                if( turn )
                    Desc += line[i] ;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movq (%rdi), %rcx
movb %al, (%rcx)
movq %rax, 0x28(%rdi)
movq %rdi, -0x30(%rbp)
movq 0x20(%rdi), %rcx
movb %al, (%rcx)
movq 0x8(%rsi), %rax
cmpq $0x1, %rax
jbe 0x8ab9
movq %rsi, %rbx
movq (%rsi), %rcx
cmpb $0x40, (%rcx)
jne 0x8ad8
cmpl $0x2, %eax
jl 0x8aaa
movq -0x30(%rbp), %rax
leaq 0x20(%rax), %r12
movl $0x1, %r13d
xorl %r14d, %r14d
movq (%rbx), %rax
movsbl (%rax,%r13), %r15d
testb $0x1, %r14b
je 0x8a77
movq %r12, %rdi
jmp 0x8a96
movl %r15d, %edi
callq 0x4280
testl %eax, %eax
movq %r12, %rdi
cmoveq -0x30(%rbp), %rdi
movzbl %r14b, %r14d
movl $0x1, %eax
cmovnel %eax, %r14d
movl %r15d, %esi
callq 0x4220
incq %r13
movslq 0x8(%rbx), %rax
cmpq %rax, %r13
jl 0x8a64
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e1c(%rip), %rdi      # 0xb8dc
leaq 0x2d52(%rip), %rsi      # 0xb819
leaq 0x2e1e(%rip), %rcx      # 0xb8ec
movl $0x42, %edx
callq 0x4190
leaq 0x2e48(%rip), %rdi      # 0xb927
leaq 0x2d33(%rip), %rsi      # 0xb819
leaq 0x2dff(%rip), %rcx      # 0xb8ec
movl $0x43, %edx
callq 0x4190
nop
// File: /workspace/github_cpp_makefile_star2_O3/BGI-Qingdao[P]ExtractNGSReads/utils/file_reader.cpp
// Function: BGIQD::FILES::FileReaderFactory::GenerateReaderFromFileName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::istream * FileReaderFactory::GenerateReaderFromFileName(const std::string & file_name )
    {
        std::istream * ret = NULL;
        if( file_name.rfind(".gz") == file_name.length() - 3 )
        {// gzip file
            ret = (new igzstream(file_name.c_str()));
        }
        else
        { // treat as txt file now //TODO
            ret = (new std::ifstream(file_name.c_str()));
        }
        if (ret && ! ret->good() )
        {
            delete ret ;
            ret = NULL;
        }
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x2e2d(%rip), %rsi      # 0xb936
movl $0x3, %ecx
movq $-0x1, %rdx
callq 0x4340
movq 0x8(%r14), %rcx
addq $-0x3, %rcx
cmpq %rcx, %rax
jne 0x8b4d
movl $0x2a0, %edi            # imm = 0x2A0
callq 0x4270
movq %rax, %rbx
movq (%r14), %rsi
movq %rax, %rdi
movl $0x8, %edx
callq 0x8cb0
addq $0x188, %rbx            # imm = 0x188
jmp 0x8b6a
movl $0x208, %edi            # imm = 0x208
callq 0x4270
movq %rax, %rbx
movq (%r14), %rsi
movq %rax, %rdi
movl $0x8, %edx
callq 0x4470
movq (%rbx), %rax
movq -0x18(%rax), %rcx
cmpl $0x0, 0x20(%rbx,%rcx)
je 0x8b80
movq %rbx, %rdi
callq *0x8(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x8b8a
movq %rax, %r14
movq %rbx, %rdi
callq 0x4240
movq %r14, %rdi
callq 0x4450
nop
// File: /workspace/github_cpp_makefile_star2_O3/BGI-Qingdao[P]ExtractNGSReads/utils/file_reader.cpp
// Function: BGIQD::FILES::FileReaderFactory::ResizeBuff(std::istream&, unsigned long)
void FileReaderFactory::ResizeBuff( std::istream & 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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
callq 0x41a0
testq %rax, %rax
je 0x8bdc
movq (%r14), %rcx
movq -0x18(%rcx), %rcx
movq 0xe8(%r14,%rcx), %rdi
movq (%rdi), %rcx
movq 0x18(%rcx), %rcx
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmpq *%rcx
movq 0x740d(%rip), %rdi      # 0xfff0
leaq 0x2d50(%rip), %rsi      # 0xb93a
callq 0x4260
movq %rax, %rdi
callq 0x4130
movl $0x1, %edi
callq 0x42f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x2985(%rip), %rsi      # 0xb936
movl $0x3, %ecx
movq $-0x1, %rdx
callq 0x4340
movq 0x8(%r14), %rcx
addq $-0x3, %rcx
cmpq %rcx, %rax
jne 0x8ff5
movl $0x298, %edi            # imm = 0x298
callq 0x4270
movq %rax, %rbx
movq (%r14), %rsi
movq %rax, %rdi
movl $0x10, %edx
callq 0x90aa
addq $0x188, %rbx            # imm = 0x188
jmp 0x9012
movl $0x200, %edi            # imm = 0x200
callq 0x4270
movq %rax, %rbx
movq (%r14), %rsi
movq %rax, %rdi
movl $0x10, %edx
callq 0x42b0
movq (%rbx), %rax
movq -0x18(%rax), %rcx
cmpl $0x0, 0x20(%rbx,%rcx)
je 0x9028
movq %rbx, %rdi
callq *0x8(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x9032
movq %rax, %r14
movq %rbx, %rdi
callq 0x4240
movq %r14, %rdi
callq 0x4450
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
callq 0x41a0
testq %rax, %rax
je 0x9084
movq (%r14), %rcx
movq -0x18(%rcx), %rcx
movq 0xe8(%r14,%rcx), %rdi
movq (%rdi), %rcx
movq 0x18(%rcx), %rcx
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmpq *%rcx
movq 0x6f65(%rip), %rdi      # 0xfff0
leaq 0x28a8(%rip), %rsi      # 0xb93a
callq 0x4260
movq %rax, %rdi
callq 0x4130
movl $0x1, %edi
callq 0x42f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
jle 0x9b92
movl %edx, %r15d
movq %rbx, -0x40(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x4330
movq %r14, -0x38(%rbp)
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x9b5e
movq -0x38(%rbp), %rax
movq (%rax), %r13
xorl %r12d, %r12d
leaq -0x29(%rbp), %rbx
movb (%r13,%r12), %al
movb %al, -0x29(%rbp)
movl $0x1, %edx
leaq -0x1b8(%rbp), %rdi
movq %rbx, %rsi
callq 0x42d0
incq %r12
movl %r12d, %eax
xorl %edx, %edx
divl %r15d
testl %edx, %edx
je 0x9b41
movq -0x38(%rbp), %rax
cmpl 0x8(%rax), %r12d
jne 0x9b59
movb $0xa, -0x29(%rbp)
movl $0x1, %edx
leaq -0x1b8(%rbp), %rdi
movq %rbx, %rsi
callq 0x42d0
cmpq %r12, %r14
jne 0x9b0c
leaq -0x1b0(%rbp), %rsi
movq -0x40(%rbp), %rbx
movq %rbx, %rdi
callq 0x43d0
movq 0x6458(%rip), %rsi      # 0xffd0
leaq -0x1b8(%rbp), %rdi
callq 0x4150
leaq -0x148(%rbp), %rdi
callq 0x40d0
jmp 0x9bab
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x6e30
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9bc2
movq %rax, %rbx
movq 0x6404(%rip), %rsi      # 0xffd0
leaq -0x1b8(%rbp), %rdi
callq 0x4150
leaq -0x148(%rbp), %rdi
callq 0x40d0
movq %rbx, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rcx
xorl %r12d, %r12d
movq %r14, %rdi
xorl %edx, %edx
callq 0x4440
cmpq $-0x1, %rax
je 0x9d2c
movq %rax, %r13
xorl %r12d, %r12d
leaq -0x50(%rbp), %rbx
movq %r13, %rcx
subq %r12, %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4290
cmpq $0x0, -0x48(%rbp)
je 0x9cf9
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0xa1e4
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %r13, %r12
addq %rcx, %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0x4440
movq %rax, %r13
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x9d26
callq 0x4240
cmpq $-0x1, %r13
jne 0x9cd2
cmpq 0x8(%r14), %r12
je 0x9d67
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq $-0x1, %rcx
callq 0x4290
leaq -0x50(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x6ece
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9d67
callq 0x4240
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
jmp 0x9d94
jmp 0x9da0
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x9da3
callq 0x4240
jmp 0x9da3
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0x717e
movq %rbx, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
movq $0x0, 0x10(%rdi)
movsbl (%rdx), %esi
xorl %r12d, %r12d
movq %r14, %rdi
xorl %edx, %edx
callq 0x4310
cmpq $-0x1, %rax
je 0x9e54
movq %rax, %r13
xorl %r12d, %r12d
leaq -0x50(%rbp), %rbx
movq %r13, %rcx
subq %r12, %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4290
cmpq $0x0, -0x48(%rbp)
je 0x9e24
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0xa1e4
movq %r13, %r12
incq %r12
movsbl (%r15), %esi
movq %r14, %rdi
movq %r12, %rdx
callq 0x4310
movq %rax, %r13
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x9e4e
callq 0x4240
cmpq $-0x1, %r13
jne 0x9dfd
cmpq 0x8(%r14), %r12
je 0x9e8f
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq $-0x1, %rcx
callq 0x4290
leaq -0x50(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x6ece
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9e8f
callq 0x4240
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
jmp 0x9ebc
jmp 0x9ec8
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x9ecb
callq 0x4240
jmp 0x9ecb
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0x717e
movq %rbx, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O3/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::vector<std::string>  split( const std::string & str) 
    {
        std::vector<std::string> ret;
        bool nb = false ;
        size_t nb_index = 0;
        for( size_t i = 0 ; i<str.size() ; i++ )
        {
            if( str[i] == ' ' || str[i] == '\n' || str[i] == '\r' || str[i] == '\t' )
            {
                if(nb)
                {
                    ret.push_back(str.substr(nb_index,i-nb_index));
                    nb = false ;
                }
            }
            else
            {
                if( !nb )
                {
                    nb =true ;
                    nb_index = i ;
                }
            }
        }
        if(nb)
        {
            ret.push_back(str.substr(nb_index,str.size() - nb_index));
            nb = false ;
        }
        return ret ;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0xa0f1
movq %rsi, %r14
xorl %r13d, %r13d
movabsq $0x100002600, %rbx      # imm = 0x100002600
leaq -0x50(%rbp), %r12
xorl %r15d, %r15d
xorl %eax, %eax
movq (%r14), %rdx
movzbl (%rdx,%r13), %edx
cmpq $0x20, %rdx
ja 0xa0a3
btq %rdx, %rbx
jae 0xa0a3
testb $0x1, %al
je 0xa0b4
movq %r13, %rcx
subq %r15, %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4290
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x6ece
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xa09b
callq 0x4240
movq 0x8(%r14), %rcx
xorl %eax, %eax
jmp 0xa0b4
testb $0x1, %al
movzbl %al, %eax
movl $0x1, %edx
cmovel %edx, %eax
cmoveq %r13, %r15
incq %r13
cmpq %rcx, %r13
jb 0xa051
testb $0x1, %al
je 0xa0f1
subq %r15, %rcx
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4290
leaq -0x50(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x6ece
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xa0f1
callq 0x4240
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa10d
jmp 0xa108
movq %rax, %r14
jmp 0xa122
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xa122
callq 0x4240
movq -0x30(%rbp), %rdi
callq 0x717e
movq %r14, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rsi
movq 0x8(%r14), %r12
movq 0x8(%rdx), %rax
movq %rax, -0x30(%rbp)
xorl %edx, %edx
movq %r12, %rcx
callq 0x4440
cmpq $-0x1, %rax
je 0xa1a0
movq %rax, %r13
movq (%rbx), %rcx
movq 0x8(%rbx), %r8
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x42c0
addq -0x30(%rbp), %r13
movq (%r14), %rsi
movq 0x8(%r14), %rcx
movq %r15, %rdi
movq %r13, %rdx
callq 0x4440
movq %rax, %r13
cmpq $-0x1, %rax
jne 0xa16c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, %rbx
xorl %r14d, %r14d
movq %r14, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x30(%rsp), %rdi
movl $0x18, %edx
callq 0x2170
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r14, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
movl $0x2d, %edx
callq 0x21b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x24bb
movq 0x8(%rsp), %r13
callq 0x2030
movq %rax, %rbp
movl (%rax), %r14d
movl $0x0, (%rax)
movq %r13, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x2050
cmpq %r13, 0x28(%rsp)
je 0x250a
movl (%rbp), %ecx
testl %ecx, %ecx
je 0x248b
cmpl $0x22, %ecx
jne 0x248f
jmp 0x2516
movl %r14d, (%rbp)
movl %eax, 0x4(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x24a9
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2429
movq %rbx, %rdi
leaq 0x4(%rsp), %rdx
callq 0x2d52
jmp 0x2429
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x24d7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2130
movq 0x2ad2(%rip), %rsi      # 0x4fb0
leaq 0x30(%rsp), %rdi
callq 0x20e0
leaq 0xb0(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb7f(%rip), %rdi       # 0x3090
callq 0x20b0
leaq 0xb73(%rip), %rdi       # 0x3090
callq 0x2150
jmp 0x2524
movq %rax, %r15
jmp 0x2536
movq %rax, %r15
cmpl $0x0, (%rbp)
jne 0x2536
movl %r14d, (%rbp)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2552
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2130
movq 0x2a57(%rip), %rsi      # 0x4fb0
leaq 0x30(%rsp), %rdi
callq 0x20e0
leaq 0xb0(%rsp), %rdi
callq 0x2060
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2584
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2130
movq %r15, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
leal (%rdx,%rsi), %eax
cmpl $0x20, %eax
jae 0x2911
movl %esi, %eax
addq %rax, %rdi
movl %edx, %ebx
addq %rdi, %rbx
movq %rbx, %rsi
callq 0x2b04
cmpq %rbx, %rax
sete %al
popq %rbx
retq
leaq 0x71a(%rip), %rdi       # 0x3032
leaq 0x72d(%rip), %rsi       # 0x304c
leaq 0x733(%rip), %rcx       # 0x3059
movl $0x1a, %edx
callq 0x20c0
movq %rax, %rdi
callq 0x2af9
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %r14d
leal (%r14,%rsi), %eax
cmpl $0x21, %eax
jae 0x2ada
movq %rdi, %rbx
movl %esi, %eax
addq %rax, %rbx
movl %r14d, %r12d
leaq (%rbx,%r12), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2b8d
movq %rax, %r13
cmpq %r15, %rax
setne %al
testl %r14d, %r14d
sete %cl
orb %al, %cl
jne 0x2aca
movq %rbx, %rdi
movl $0x1, %esi
movq %r12, %rdx
callq 0x20a0
cmpq %r15, %r13
sete %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x5b5(%rip), %rdi       # 0x3096
leaq 0x564(%rip), %rsi       # 0x304c
leaq 0x5c3(%rip), %rcx       # 0x30b2
movl $0xe, %edx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x2b0f(%rip), %rdi      # 0x3fe0
leaq 0xc(%rsp), %rsi
callq 0x1060
cmpl $0x0, 0xc(%rsp)
jle 0x1542
xorl %ebp, %ebp
movq 0x2af5(%rip), %rbx      # 0x3fe0
leaq 0x34(%rsp), %r14
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1060
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x151d
movl 0x34(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x1528
movq %r15, %rdi
movq %r14, %rdx
callq 0x159c
incl %ebp
cmpl 0xc(%rsp), %ebp
jl 0x14f5
movq 0x18(%rsp), %rdx
subq 0x10(%rsp), %rdx
shrq $0x2, %rdx
decl %edx
jmp 0x1547
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x125c
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x156a
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1579
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1593
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq %rbx, %rdi
callq 0x1110
nop
// File: /workspace/github_cpp_makefile_star2_O3/grogers0[P]dots_and_boxes/BruteForce.cpp
// Function: brute_force(Board const&)
void brute_force(const Board &oldboard)
{
    std::vector<Edge> edges;

    std::for_each(oldboard.edge_begin(), oldboard.edge_end(), [&] (Edge edge)
            { if (oldboard.is_move_valid(edge)) edges.push_back(edge); });

    std::vector<std::pair<Edge, short>> table;
    table.resize(((unsigned long)1) << oldboard.num_edges(), std::make_pair(Edge(), SHRT_MAX));
    table.back().second = 0; // initialize the final state

    std::sort(edges.begin(), edges.end());
    for (std::vector<Edge>::iterator middle = --edges.end();
            middle != edges.begin(); --middle) {
        do_brute_force_one_level(oldboard, table, edges.begin(), middle, edges.end());
    }

    do_brute_force_one_level(oldboard, table, edges.begin(), edges.begin(), edges.end());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movl (%rdi), %eax
movl 0x4(%rdi), %ecx
shlq $0x20, %rax
leaq 0x20(%rsp), %r15
movq %rax, (%r15)
movl %ecx, 0x8(%r15)
leaq 0x38(%rsp), %r12
movl 0x20(%rsp), %ebp
movl %ebp, 0x38(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2730
testb %al, %al
je 0x4709
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x46fe
movl %ebp, (%rsi)
addq $0x4, 0x8(%rsp)
jmp 0x4709
movq %r14, %rdi
movq %r12, %rdx
callq 0x42ac
movq %r15, %rdi
callq 0x4244
movzwl 0x20(%rsp), %eax
cmpw $-0x2, %ax
setb %cl
orb %al, %cl
testb $0x1, %cl
jne 0x46d2
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl (%rbx), %ecx
movl 0x4(%rbx), %eax
leal 0x1(%rax), %edx
imull %ecx, %edx
incl %ecx
imull %eax, %ecx
addl %edx, %ecx
movl $0x1, %esi
shlq %cl, %rsi
leaq 0x38(%rsp), %rdx
movl $0x0, (%rdx)
movw $0x7fff, 0x4(%rdx)      # imm = 0x7FFF
callq 0x48f8
movq 0x28(%rsp), %rax
movw $0x0, -0x4(%rax)
movq (%rsp), %r15
movq 0x8(%rsp), %r14
cmpq %r14, %r15
je 0x47b2
movq %r14, %rax
subq %r15, %rax
sarq $0x2, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x4df5
movq %r15, %rdi
movq %r14, %rsi
callq 0x4ea8
movq 0x8(%rsp), %r14
addq $-0x4, %r14
leaq 0x20(%rsp), %r15
movq (%rsp), %rdx
movq 0x8(%rsp), %r8
cmpq %rdx, %r14
je 0x47e0
leaq -0x4(%r14), %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x43f0
movq %r12, %r14
jmp 0x47bb
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movq %rdx, %rcx
callq 0x43f0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x4807
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x481d
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x482e
jmp 0x482e
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x484d
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
jmp 0x484d
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4863
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
subq $0x48, %rsp
cmpl $0x2, %edi
jle 0x48c4
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x2230
movl %eax, %ebp
movq 0x10(%rbx), %rdi
callq 0x2230
movq %rsp, %rbx
movq %rbx, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x252c
movq %rbx, %rdi
callq 0x4697
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x48bb
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1c08(%rip), %rdi      # 0x64d3
callq 0x2210
movl $0x1, %edi
callq 0x21a0
movq %rax, %rbx
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x48ef
movq %rsp, %rdi
callq 0x23f1
movq %rbx, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movzwl (%rdi), %ecx
movl %ecx, %edx
andl $0x1, %edx
movl %esi, %edi
andl $0x1, %edi
movb $0x1, %al
cmpl %edx, %edi
ja 0x4b69
jae 0x4b6a
xorl %eax, %eax
retq
movsbl %cl, %edx
shrl %edx
movsbl %sil, %edi
shrl %edi
cmpw %di, %dx
jl 0x4b69
jg 0x4b67
movswl %cx, %eax
shrl $0x8, %eax
movswl %si, %ecx
shrl $0x8, %ecx
cmpw %cx, %ax
setl %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/LiuYinCarl[P]headerFileAnalysis/headerFileAnalysis.cpp
// Function: Graph::add_node(Node*)
bool Graph::add_node(Node* node) {
  std::string name = node->get_node_name();
  if (node_name_map.count(name) > 0) {
    return false;
  }
  uint32_t node_id = node->get_node_id();
  auto node_iter = node_map.find(node_id);
  assert(node_iter == node_map.end());
  const auto [it, succ] = node_map.insert({node_id, node});
  assert(succ);
  const auto [it2, succ2] = node_name_map.insert({node->get_node_name(), node});
  assert(succ2);

  ++node_count;
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x38(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq 0x8(%rsi), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x6d38
leaq 0x38(%rbx), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x6f0a
movq %rax, %r14
leaq 0x40(%rbx), %r13
cmpq %r13, %rax
jne 0x4c82
movl (%r15), %eax
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x4c12
leaq 0x10(%rbx), %rsi
movq %rsi, %rdx
xorl %edi, %edi
cmpl %eax, 0x20(%rcx)
setb %dil
cmovaeq %rcx, %rdx
movq 0x10(%rcx,%rdi,8), %rcx
testq %rcx, %rcx
jne 0x4bed
cmpq %rsi, %rdx
je 0x4c12
cmpl 0x20(%rdx), %eax
jae 0x4cec
leaq 0x8(%rbx), %rdi
movq %rsp, %rsi
movl %eax, (%rsi)
movq %r15, 0x8(%rsi)
callq 0x6f94
testb $0x1, %dl
je 0x4cae
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x6d38
movq %rsp, %rsi
movq %r15, 0x20(%rsi)
movq %r12, %rdi
callq 0x70a4
movl %edx, %ebp
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x4c75
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4330
testb $0x1, %bpl
je 0x4ccd
incl (%rbx)
leaq 0x38(%rsp), %rbp
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4c99
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4330
cmpq %r13, %r14
sete %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13569(%rip), %rdi     # 0x1821e
leaq 0x134a3(%rip), %rsi     # 0x1815f
leaq 0x1353e(%rip), %rcx     # 0x18201
movl $0x5c, %edx
callq 0x4230
leaq 0x1354f(%rip), %rdi     # 0x18223
leaq 0x13484(%rip), %rsi     # 0x1815f
leaq 0x1351f(%rip), %rcx     # 0x18201
movl $0x5e, %edx
callq 0x4230
leaq 0x134f2(%rip), %rdi     # 0x181e5
leaq 0x13465(%rip), %rsi     # 0x1815f
leaq 0x13500(%rip), %rcx     # 0x18201
movl $0x5a, %edx
callq 0x4230
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x4d32
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4330
jmp 0x4d32
jmp 0x4d2f
jmp 0x4d2f
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x4d4e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4330
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_cpp_makefile_star2_O3/LiuYinCarl[P]headerFileAnalysis/headerFileAnalysis.cpp
// Function: Graph::check_circle()
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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rdi), %r14
leaq 0x10(%rdi), %rbp
cmpq %rbp, %r14
je 0x52be
movq %rdi, %rbx
leaq 0x68(%rdi), %r15
leaq 0x98(%rdi), %r12
movl 0x20(%r14), %r13d
movq 0x28(%r14), %rsi
movq %rbx, %rdi
leaq 0x10(%rsp), %rdx
callq 0x4fec
movl %r13d, 0xc(%rsp)
movq %r15, %rdi
leaq 0xc(%rsp), %rsi
callq 0x72ea
movq %r12, %rdi
callq 0x75ca
movq 0x10(%rsp), %r13
cmpq %r13, 0x18(%rsp)
jne 0x52cd
movq %r14, %rdi
callq 0x4260
movq %rax, %r14
cmpq %rbp, %rax
jne 0x525e
testq %r13, %r13
je 0x52be
movq 0x20(%rsp), %rsi
subq %r13, %rsi
movq %r13, %rdi
callq 0x4330
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1307c(%rip), %rdi     # 0x18350
leaq 0x12e84(%rip), %rsi     # 0x1815f
leaq 0x13086(%rip), %rcx     # 0x18368
movl $0xb7, %edx
callq 0x4230
jmp 0x52ee
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x5308
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x4330
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
cmpq $0x0, 0x8(%rsi)
je 0x4ddb
movq %rdi, %rbx
addq $0x38, %rdi
callq 0x7260
addq $0x40, %rbx
cmpq %rbx, %rax
je 0x4dd7
movq 0x40(%rax), %rax
jmp 0x4dd9
xorl %eax, %eax
popq %rbx
retq
leaq 0x134e5(%rip), %rdi     # 0x182c7
leaq 0x13376(%rip), %rsi     # 0x1815f
leaq 0x1345f(%rip), %rcx     # 0x1824f
movl $0x6e, %edx
callq 0x4230
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x4e55
movq %rdx, %r15
cmpq $0x0, 0x8(%rdx)
je 0x4e74
movq %rsi, %rbx
movq %rdi, %r14
movq %r15, %rsi
callq 0x4db4
movq %rax, %r12
testq %rax, %rax
jne 0x4e3d
movq %r15, %rdi
callq 0x4e93
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x4b86
movl (%rbx), %esi
movq %r12, %rdi
callq 0x4a60
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x13426(%rip), %rdi     # 0x18282
leaq 0x132fc(%rip), %rsi     # 0x1815f
leaq 0x13428(%rip), %rcx     # 0x18292
movl $0x77, %edx
callq 0x4230
leaq 0x13445(%rip), %rdi     # 0x182c0
leaq 0x132dd(%rip), %rsi     # 0x1815f
leaq 0x13409(%rip), %rcx     # 0x18292
movl $0x78, %edx
callq 0x4230
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x13567(%rip), %rsi     # 0x18408
callq 0x40b0
testl %eax, %eax
je 0x4eda
movl 0x1e898(%rip), %ebp     # 0x23748
incl %ebp
movl %ebp, 0x1e890(%rip)     # 0x23748
movl $0x40, %edi
callq 0x4320
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x4912
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x136a1(%rip), %rdi     # 0x18582
leaq 0x136a5(%rip), %rsi     # 0x1858d
leaq 0x136b5(%rip), %rcx     # 0x185a4
movl $0x3e, %edx
callq 0x4230
movq %rax, %rbx
movl $0x40, %esi
movq %r14, %rdi
callq 0x4330
movq %rbx, %rdi
callq 0x44e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/LiuYinCarl[P]headerFileAnalysis/headerFileAnalysis.cpp
// Function: Graph::gen_dot_file()
bool Graph::gen_dot_file() {
  FILE* fp = fopen("include_graph.dot", "w");
  assert(fp != nullptr);
  // gen node define
  Node* tmp_node = nullptr;
  // ratio 图像高:宽
  // splines=false; 使用直线绘图
  fprintf(fp, "digraph {\n\n graph [ratio = 0.5];\n");
  fprintf(fp, "// node define\n");
  for (auto& item : node_map) {
    tmp_node = item.second;
    fprintf(fp, "%d[label=\"%s %d\"];\n",
            item.first,
            tmp_node->get_node_name().c_str(),
            tmp_node->get_child_node_count());
  }

  fprintf(fp, "\n\n");

  // gen line
  for (auto& item : node_map) {
    Node* node = item.second;
    uint32_t self_node_id = item.first;

    for (auto& child_id : node->get_child_nodes()) {
      fprintf(fp, "%d -> %d;\n", child_id, self_node_id);
    }
  }
  fprintf(fp, "\n}");
  fclose(fp);
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x1305e(%rip), %rdi     # 0x18383
leaq 0x13069(%rip), %rsi     # 0x18395
callq 0x43e0
testq %rax, %rax
je 0x545c
movq %rax, %rbx
leaq 0x1307c(%rip), %rdi     # 0x183c0
movl $0x21, %esi
movl $0x1, %edx
movq %rax, %rcx
callq 0x4570
leaq 0x13085(%rip), %rdi     # 0x183e2
movl $0xf, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x4570
movq 0x20(%r14), %r15
leaq 0x10(%r14), %r13
cmpq %r13, %r15
je 0x53b8
leaq 0x1306f(%rip), %r12     # 0x183f2
movq 0x28(%r15), %rax
movl 0x20(%r15), %edx
movq 0x8(%rax), %rcx
movq 0x30(%rax), %r8
subq 0x28(%rax), %r8
shrq $0x2, %r8
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x4460
movq %r15, %rdi
callq 0x4260
movq %rax, %r15
cmpq %r13, %rax
jne 0x5383
leaq 0x13047(%rip), %rdi     # 0x18406
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x4570
movq 0x20(%r14), %r14
cmpq %r13, %r14
je 0x542a
leaq 0x13028(%rip), %r15     # 0x18409
movq %r13, (%rsp)
movq 0x28(%r14), %rax
movq 0x28(%rax), %r12
movq 0x30(%rax), %r13
cmpq %r13, %r12
je 0x5416
movl 0x20(%r14), %ebp
movl (%r12), %edx
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x4460
addq $0x4, %r12
cmpq %r13, %r12
jne 0x53fa
movq %r14, %rdi
callq 0x4260
movq %rax, %r14
movq (%rsp), %r13
cmpq %r13, %rax
jne 0x53e5
leaq 0x12fe3(%rip), %rdi     # 0x18414
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x4570
movq %rbx, %rdi
callq 0x4310
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12f34(%rip), %rdi     # 0x18397
leaq 0x12cf5(%rip), %rsi     # 0x1815f
leaq 0x12f34(%rip), %rcx     # 0x183a5
movl $0xbd, %edx
callq 0x4230
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x570a
movq %rbx, %rdi
callq 0x59ea
movq %rbx, %rdi
callq 0x60d6
movq %rbx, %rdi
callq 0x617e
movq %rbx, %rdi
callq 0x5224
movq %rbx, %rdi
callq 0x5310
movq 0x1cce4(%rip), %r14     # 0x22fb8
leaq 0x12238(%rip), %rsi     # 0x18513
movl $0x15, %edx
movq %r14, %rdi
callq 0x43a0
movq 0xf8(%rbx), %rax
subq 0xf0(%rbx), %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rsi
movq %r14, %rdi
callq 0x4240
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x42f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4250
leaq 0x121e8(%rip), %rsi     # 0x18529
movl $0x15, %edx
movq %r14, %rdi
callq 0x43a0
movq 0x130(%rbx), %rsi
movq %r14, %rdi
callq 0x4240
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x42f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4250
leaq 0x121b1(%rip), %rsi     # 0x1853f
movl $0x15, %edx
movq %r14, %rdi
callq 0x43a0
movl (%rbx), %esi
movq %r14, %rdi
callq 0x4240
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4250
// File: /workspace/github_cpp_makefile_star2_O3/LiuYinCarl[P]headerFileAnalysis/headerFileAnalysis.cpp
// Function: main
int main(int argc, char* argv[]) {
  if (argc != 2) {
    std::cout << "usage: ./headerFileAnalysys path/to/project/" << std::endl;
    exit(0);
  }

  std::string base_dir {argv[1]};

  WalkMan walkMan(base_dir);
  walkMan.start();

  return 0;
}

// Assembly:
pushq %rbx
subq $0x170, %rsp            # imm = 0x170
cmpl $0x2, %edi
jne 0x643c
movq 0x8(%rsi), %rsi
movq %rsp, %rbx
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x6494
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x555a
leaq 0x20(%rsp), %rdi
callq 0x6298
leaq 0x20(%rsp), %rdi
callq 0x5650
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6431
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4330
xorl %eax, %eax
addq $0x170, %rsp            # imm = 0x170
popq %rbx
retq
movq 0x1cb75(%rip), %rdi     # 0x22fb8
leaq 0x1210b(%rip), %rsi     # 0x18555
callq 0x4300
movq %rax, %rdi
callq 0x4170
xorl %edi, %edi
callq 0x43f0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5650
jmp 0x6470
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x648b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4330
movq %rbx, %rdi
callq 0x44e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/lrq3000[P]rfrb/./src/raidSystem.cpp
// Function: RaidSystem::RaidSystem(FileHandler*)
RaidSystem::RaidSystem(FileHandler *fileHandler)
{
	handle = fileHandler;
	raidSystem = Raid_unknown;
	stripeSize = -1;
	lostImages = -1;
	raidSystem = Raid_unknown;
	srand(time(NULL));
}

// Assembly:
pushq %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
movq %rsi, (%rdi)
movl $0xffffffff, 0x28(%rdi) # imm = 0xFFFFFFFF
movabsq $-0xfffffffb, %rax      # imm = 0xFFFFFFFF00000005
movq %rax, 0x8(%rdi)
xorl %edi, %edi
callq 0x5370
movl %eax, %edi
popq %rax
jmp 0x53a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/lrq3000[P]rfrb/./src/raidSystem.cpp
// Function: RaidSystem::calculateStripeSize()
bool RaidSystem::calculateStripeSize()
{
	int ret = handle->estimateStripeSize();
	if (ret == -1)
		return false;
	this->stripeSize = ret;
	return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x8bea
cmpl $-0x1, %eax
je 0x7086
movl %eax, 0xc(%rbx)
cmpl $-0x1, %eax
setne %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/lrq3000[P]rfrb/./src/raidSystem.cpp
// Function: RaidSystem::checkForNull(char*, unsigned long)
bool RaidSystem::checkForNull(char *in, size_t size)
{
	for (size_t i = 0; i < size; ++i)
	{
		if (in[i] > 0)
			return false;
	}
	return true;
}

// Assembly:
testq %rdx, %rdx
je 0x7d75
cmpb $0x0, (%rsi)
jle 0x7d78
xorl %eax, %eax
retq
movb $0x1, %al
retq
movl $0x1, %ecx
movq %rcx, %rax
cmpq %rcx, %rdx
je 0x7d8f
leaq 0x1(%rax), %rcx
cmpb $0x0, (%rsi,%rax)
jle 0x7d7d
cmpq %rdx, %rax
setae %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/lrq3000[P]rfrb/./src/raidSystem.cpp
// Function: RaidSystem::checkForEqual(char*, char*, unsigned long)
bool RaidSystem::checkForEqual(char *buf, char *in, size_t size)
{
	unsigned int count = 0;
	for (size_t i = 0; i < size; ++i)
	{
		if (in[i] != buf[i])
			++count;
	}
	//A few errors are tolerated
	if (count > (size/1000))
		return false;

	return true;
}

// Assembly:
movq %rcx, %rax
xorl %ecx, %ecx
testq %rax, %rax
je 0x7dbe
xorl %edi, %edi
movb (%rdx,%rdi), %r8b
xorl %r9d, %r9d
cmpb (%rsi,%rdi), %r8b
setne %r9b
addl %r9d, %ecx
incq %rdi
cmpq %rdi, %rax
jne 0x7da2
movl %ecx, %ecx
shrq $0x3, %rax
movabsq $0x20c49ba5e353f7cf, %rdx # imm = 0x20C49BA5E353F7CF
mulq %rdx
shrq $0x4, %rdx
cmpq %rcx, %rdx
setae %al
retq