LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/BGI-Qingdao[P]ExtractNGSReads/./utils/argsparser.h
// Function: BGIQD::ARGS::args_union::args_to_string[abi:cxx11]()
std::string args_to_string() 
            {
                if( t == is_bool )
                    return d.b ? "true" : "false";
                if( t == is_int)
                    return std::to_string(d.i);
                if( t == is_long)
                    return std::to_string(d.l);
                if( t == is_float)
                    return std::to_string(d.f);
                if( t == is_string)
                    return to_string();
                if( t == is_vector_string)
                {
                    std::string ret ;
                    for(const auto & i : to_vector_string())
                    {
                        ret += "\t";
                        ret += i;
                    }
                    return ret ;
                }
                return "";
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl 0x68(%rsi), %eax
cmpq $0x5, %rax
ja 0x5d54
leaq 0x4376(%rip), %rcx      # 0xa01c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x465a(%rip), %rcx      # 0xa310
leaq 0x4658(%rip), %rax      # 0xa315
cmpb $0x0, 0x70(%rsi)
cmovneq %rcx, %rax
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x5d62
movss 0x70(%rsi), %xmm0
movq %rbx, %rdi
callq 0x6862
jmp 0x5d72
movl 0x70(%rsi), %esi
movq %rbx, %rdi
callq 0x67a2
jmp 0x5d72
movq 0x70(%rsi), %rsi
movq %rbx, %rdi
callq 0x6802
jmp 0x5d72
movq %rbx, %rdi
callq 0x5da4
jmp 0x5d72
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq -0x38(%rbp), %rdi
callq 0x6892
movq -0x38(%rbp), %r14
movq -0x30(%rbp), %r12
leaq 0x43ba(%rip), %r15      # 0xa0ed
cmpq %r12, %r14
je 0x5d69
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4480
movq %rbx, %rdi
movq %r14, %rsi
callq 0x44a0
addq $0x20, %r14
jmp 0x5d33
leaq 0x4393(%rip), %rsi      # 0xa0ee
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x4120
jmp 0x5d72
leaq -0x38(%rbp), %rdi
callq 0x68d8
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x5d93
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x68d8
movq %rbx, %rdi
callq 0x4140
movq %r14, %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O2/BGI-Qingdao[P]ExtractNGSReads/./utils/argsparser.h
// Function: BGIQD::ARGS::args_union::~args_union()
~args_union()
            {
                if( t == is_string && d.s )
                    delete d.s ;
                if ( t== is_vector_string && d.vs )
                    delete d.vs ;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x68(%rdi), %eax
cmpl $0x1, %eax
jne 0x60cc
movq 0x70(%rbx), %r14
testq %r14, %r14
je 0x60ea
movq %r14, %rdi
callq 0x4140
movq %r14, %rdi
callq 0x4250
movl 0x68(%rbx), %eax
cmpl $0x5, %eax
jne 0x60ea
movq 0x70(%rbx), %r14
testq %r14, %r14
je 0x60ea
movq %r14, %rdi
callq 0x68d8
movq %r14, %rdi
callq 0x4250
leaq 0x48(%rbx), %rdi
callq 0x4140
leaq 0x28(%rbx), %rdi
callq 0x4140
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4140
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6c6f
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 0x4170
addq $0x30, %r14
leaq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x4170
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BGI-Qingdao[P]ExtractNGSReads/./utils/fastq.h
// Function: BGIQD::FASTQ::Fastq<BGIQD::FASTQ::stLFRHeader>::Reset()
void Reset() 
                {
                    head.Reset();
                    seq.Reset();
                    quality.Reset();
                    flags = 0 ;
                    Set_UnSet();
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x72f0
andq $0x0, 0x60(%rbx)
movq 0x58(%rbx), %rax
xorl %ecx, %ecx
movb %cl, (%rax)
andq $0x0, 0x80(%rbx)
movq 0x78(%rbx), %rax
movb %cl, (%rax)
andq $0x0, (%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7326
nop
// File: /workspace/github_cpp_makefile_star2_O2/BGI-Qingdao[P]ExtractNGSReads/./utils/fastq.h
// Function: BGIQD::FASTQ::Fastq<BGIQD::FASTQ::stLFRHeader>::Is_Setted() const
bool Is_Setted() const { 
                    return  (!Is_UnSet() )
                        && Is_Set_head() 
                        && Is_Set_seq()
                        && Is_Set_3() 
                        && Is_Set_quality();
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x73c8
testb %al, %al
jne 0x710a
movq %rbx, %rdi
callq 0x73dc
testb %al, %al
je 0x710a
movq %rbx, %rdi
callq 0x73f0
testb %al, %al
je 0x710a
movq %rbx, %rdi
callq 0x7404
testb %al, %al
je 0x710a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7418
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/BGI-Qingdao[P]ExtractNGSReads/./utils/fastq.h
// Function: BGIQD::FASTQ::Fastq<BGIQD::FASTQ::stLFRHeader>::AddSeq(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void AddSeq(const std::string & line )
                {
                    if( Is_UnSet() || ! Is_Set_head() )
                    {
                        assert(0);
                    }
                    Set_Set_seq();
                    seq.AddPartSeq(line);
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x73c8
testb %al, %al
jne 0x71bd
movq %r14, %rdi
callq 0x73dc
testb %al, %al
je 0x71bd
movq %r14, %rdi
callq 0x77f0
addq $0x58, %r14
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x44a0
leaq 0x33a5(%rip), %rdi      # 0xa569
leaq 0x324c(%rip), %rsi      # 0xa417
leaq 0x3399(%rip), %rcx      # 0xa56b
movl $0x86, %edx
callq 0x41b0
// File: /workspace/github_cpp_makefile_star2_O2/BGI-Qingdao[P]ExtractNGSReads/./utils/fastq.h
// Function: BGIQD::FASTQ::Fastq<BGIQD::FASTQ::stLFRHeader>::Add3(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Add3(const std::string & )
                {
                    if( Is_UnSet()
                            || ! Is_Set_head() 
                            || ! Is_Set_seq() )
                    {
                        assert(0);
                    }
                    Set_Set_3();
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x73c8
testb %al, %al
jne 0x7214
movq %rbx, %rdi
callq 0x73dc
testb %al, %al
je 0x7214
movq %rbx, %rdi
callq 0x73f0
testb %al, %al
je 0x7214
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x780a
leaq 0x334e(%rip), %rdi      # 0xa569
leaq 0x31f5(%rip), %rsi      # 0xa417
leaq 0x33b3(%rip), %rcx      # 0xa5dc
movl $0x92, %edx
callq 0x41b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/BGI-Qingdao[P]ExtractNGSReads/./utils/fastq.h
// Function: BGIQD::FASTQ::Fastq<BGIQD::FASTQ::stLFRHeader>::AddQuality(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void AddQuality( const std::string & line )
                {

                    if( Is_UnSet() || ! Is_Set_3() )
                    {
                        assert(0);
                    }
                    Set_Set_quality();
                    quality.AddPartSeq(line);
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x73c8
testb %al, %al
jne 0x7271
movq %r14, %rdi
callq 0x7404
testb %al, %al
je 0x7271
movq %r14, %rdi
callq 0x7824
addq $0x78, %r14
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x44a0
leaq 0x32f1(%rip), %rdi      # 0xa569
leaq 0x3198(%rip), %rsi      # 0xa417
leaq 0x33c5(%rip), %rcx      # 0xa64b
movl $0x9c, %edx
callq 0x41b0
// File: /workspace/github_cpp_makefile_star2_O2/BGI-Qingdao[P]ExtractNGSReads/./utils/fastq.h
// Function: BGIQD::FASTQ::stLFRHeader::Reset()
void Reset()
            {
                type = Unknow ;
                readName ="";
                barcode_str = "" ;
                readIndex = 0 ;
                barcode_num = 0 ;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
andl $0x0, (%rdi)
addq $0x30, %rdi
leaq 0x2de6(%rip), %r14      # 0xa0ee
movq %r14, %rsi
callq 0x4490
leaq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x4490
andq $0x0, 0x4(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rsi, %r15
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
xorl %eax, %eax
movb %al, 0x20(%rdi)
leaq 0x30(%rdi), %r14
leaq 0x40(%rdi), %rcx
movq %rcx, 0x30(%rdi)
andq $0x0, 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 0x4170
addq $0x30, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4170
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x4140
movq %rbx, %rdi
callq 0x4140
movq %r15, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x178, %rsp            # imm = 0x178
cmpl $0x0, (%rsi)
je 0x826f
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x190(%rbp), %r15
movq %r15, %rdi
callq 0x4330
pushq $0x40
popq %rsi
movq %r15, %rdi
callq 0x42d0
leaq 0x30(%r14), %rsi
movq %rax, %rdi
callq 0x4240
pushq $0x23
popq %rsi
movq %rax, %rdi
callq 0x42d0
leaq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x4240
movl (%r14), %eax
cmpl $0x2, %eax
jne 0x820c
leaq -0x190(%rbp), %rdi
pushq $0x2f
popq %rsi
callq 0x42d0
movl 0x4(%r14), %esi
movq %rax, %rdi
callq 0x4410
movl (%r14), %eax
cmpl $0x3, %eax
jne 0x8243
leaq -0x190(%rbp), %rdi
pushq $0x2f
popq %rsi
callq 0x42d0
movl 0x4(%r14), %esi
movq %rax, %rdi
callq 0x4410
pushq $0x9
popq %rsi
movq %rax, %rdi
callq 0x42d0
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x4410
leaq -0x188(%rbp), %rsi
movq %rbx, %rdi
callq 0x43c0
leaq -0x190(%rbp), %rdi
callq 0x4080
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2673(%rip), %rdi      # 0xa8e9
leaq 0x25ec(%rip), %rsi      # 0xa869
leaq 0x2674(%rip), %rcx      # 0xa8f8
pushq $0x34
popq %rdx
callq 0x41b0
movq %rax, %rbx
leaq -0x190(%rbp), %rdi
callq 0x4080
movq %rbx, %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x8(%rdi)
movq (%rdi), %rax
xorl %ecx, %ecx
movb %cl, (%rax)
andq $0x0, 0x28(%rdi)
movq %rdi, -0x30(%rbp)
movq 0x20(%rdi), %rax
movb %cl, (%rax)
movq 0x8(%rsi), %rax
cmpq $0x1, %rax
jbe 0x8344
movq %rsi, %r14
movq (%rsi), %rcx
cmpb $0x40, (%rcx)
jne 0x835d
movq -0x30(%rbp), %rcx
leaq 0x20(%rcx), %r12
pushq $0x1
popq %r13
xorl %ebx, %ebx
cltq
cmpq %rax, %r13
jge 0x8335
movq (%r14), %rax
movsbl (%rax,%r13), %r15d
testb $0x1, %bl
je 0x8309
movq %r12, %rdi
jmp 0x8324
movl %r15d, %edi
callq 0x4280
testl %eax, %eax
movq %r12, %rdi
cmoveq -0x30(%rbp), %rdi
movzbl %bl, %ebx
pushq $0x1
popq %rax
cmovnel %eax, %ebx
movl %r15d, %esi
callq 0x4220
incq %r13
movq 0x8(%r14), %rax
jmp 0x82f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25e1(%rip), %rdi      # 0xa92c
leaq 0x2517(%rip), %rsi      # 0xa869
leaq 0x25e3(%rip), %rcx      # 0xa93c
pushq $0x42
jmp 0x8374
leaq 0x2613(%rip), %rdi      # 0xa977
leaq 0x24fe(%rip), %rsi      # 0xa869
leaq 0x25ca(%rip), %rcx      # 0xa93c
pushq $0x43
popq %rdx
callq 0x41b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x25f9(%rip), %rsi      # 0xa986
pushq $-0x1
popq %rdx
callq 0x43e0
movq 0x8(%r14), %rcx
addq $-0x3, %rcx
cmpq %rcx, %rax
jne 0x83c6
movl $0x2a0, %edi            # imm = 0x2A0
callq 0x4270
movq %rax, %rbx
movq (%r14), %rsi
pushq $0x8
popq %rdx
movq %rax, %rdi
callq 0x84ea
addq $0x188, %rbx            # imm = 0x188
jmp 0x83e1
movl $0x208, %edi            # imm = 0x208
callq 0x4270
movq %rax, %rbx
movq (%r14), %rsi
pushq $0x8
popq %rdx
movq %rax, %rdi
callq 0x4460
movq (%rbx), %rax
movq -0x18(%rax), %rcx
cmpl $0x0, 0x20(%rbx,%rcx)
je 0x83f7
movq %rbx, %rdi
callq *0x8(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x8401
movq %rax, %r14
movq %rbx, %rdi
callq 0x4250
movq %r14, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rdi
callq 0x41c0
testq %rax, %rax
je 0x8450
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 0x6b99(%rip), %rdi      # 0xeff0
leaq 0x252c(%rip), %rsi      # 0xa98a
callq 0x4260
movq %rax, %rdi
callq 0x4150
pushq $0x1
popq %rdi
callq 0x42e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x22f5(%rip), %rsi      # 0xa986
pushq $-0x1
popq %rdx
callq 0x43e0
movq 0x8(%r14), %rcx
addq $-0x3, %rcx
cmpq %rcx, %rax
jne 0x86ca
movl $0x298, %edi            # imm = 0x298
callq 0x4270
movq %rax, %rbx
movq (%r14), %rsi
pushq $0x10
popq %rdx
movq %rax, %rdi
callq 0x8778
addq $0x188, %rbx            # imm = 0x188
jmp 0x86e5
movl $0x200, %edi            # imm = 0x200
callq 0x4270
movq %rax, %rbx
movq (%r14), %rsi
pushq $0x10
popq %rdx
movq %rax, %rdi
callq 0x42b0
movq (%rbx), %rax
movq -0x18(%rax), %rcx
cmpl $0x0, 0x20(%rbx,%rcx)
je 0x86fb
movq %rbx, %rdi
callq *0x8(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x8705
movq %rax, %r14
movq %rbx, %rdi
callq 0x4250
movq %r14, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rdi
callq 0x41c0
testq %rax, %rax
je 0x8754
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 0x6895(%rip), %rdi      # 0xeff0
leaq 0x2228(%rip), %rsi      # 0xa98a
callq 0x4260
movq %rax, %rdi
callq 0x4150
pushq $0x1
popq %rdi
callq 0x42e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %edx, %r14d
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
andq $0x0, -0x8(%r12)
movq %rsi, %r15
movq %rdi, %rbx
movb $0x0, (%r12)
movq 0x8(%rsi), %rsi
leaq -0x48(%rbp), %rdi
pushq $0x4e
popq %rdx
callq 0x40c0
movq (%r15), %rdx
movq 0x8(%r15), %rax
addq %rdx, %rax
xorl %ecx, %ecx
cmpq %rdx, %rax
je 0x8e38
movzbl -0x1(%rax), %esi
movb $0x54, %dl
cmpl $0x41, %esi
je 0x8e26
cmpl $0x43, %esi
je 0x8e1c
cmpl $0x47, %esi
je 0x8e18
cmpl $0x54, %esi
je 0x8e20
cmpl $0x61, %esi
je 0x8e26
cmpl $0x63, %esi
je 0x8e1c
cmpl $0x74, %esi
je 0x8e20
cmpl $0x67, %esi
jne 0x8e24
movb $0x43, %dl
jmp 0x8e26
movb $0x47, %dl
jmp 0x8e26
movb $0x41, %dl
jmp 0x8e26
movl %esi, %edx
decq %rax
movq -0x48(%rbp), %rsi
movb %dl, (%rsi,%rcx)
incq %rcx
movq (%r15), %rdx
jmp 0x8de5
testl %r14d, %r14d
jle 0x8eb4
movq %rbx, -0x50(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x4330
movq -0x48(%rbp), %rbx
movq -0x40(%rbp), %r13
xorl %r15d, %r15d
leaq -0x1c8(%rbp), %r12
cmpq %r15, %r13
je 0x8e93
movsbl (%rbx,%r15), %esi
movq %r12, %rdi
callq 0x42d0
incq %r15
movl %r15d, %eax
xorl %edx, %edx
divl %r14d
testl %edx, %edx
je 0x8e86
cmpl -0x40(%rbp), %r15d
jne 0x8e5f
movq %r12, %rdi
pushq $0xa
popq %rsi
callq 0x42d0
jmp 0x8e5f
leaq -0x1c0(%rbp), %rsi
movq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x43c0
leaq -0x1c8(%rbp), %rdi
callq 0x4080
jmp 0x8eee
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq -0x48(%rbp), %rcx
cmpq %r12, %rcx
je 0x8ed1
movq %rcx, (%rbx)
movq -0x38(%rbp), %rax
movq %rax, 0x10(%rbx)
jmp 0x8ed9
movups (%r12), %xmm0
movups %xmm0, (%rax)
movq -0x40(%rbp), %rax
movq %rax, 0x8(%rbx)
movq %r12, -0x48(%rbp)
andq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4140
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8f15
jmp 0x8f10
movq %rax, %rbx
jmp 0x8f24
movq %rax, %rbx
leaq -0x1c8(%rbp), %rdi
callq 0x4080
leaq -0x48(%rbp), %rdi
callq 0x4140
movq %rbx, %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
jle 0x8fd2
movl %edx, %r15d
movq %rbx, -0x30(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x4330
movq (%r14), %rbx
movq %r14, %r12
movq 0x8(%r14), %r14
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x8fb1
movsbl (%rbx,%r13), %esi
leaq -0x1a8(%rbp), %rdi
callq 0x42d0
incq %r13
movl %r13d, %eax
xorl %edx, %edx
divl %r15d
testl %edx, %edx
je 0x8fa0
cmpl 0x8(%r12), %r13d
jne 0x8f74
leaq -0x1a8(%rbp), %rdi
pushq $0xa
popq %rsi
callq 0x42d0
jmp 0x8f74
leaq -0x1a0(%rbp), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x43c0
leaq -0x1a8(%rbp), %rdi
callq 0x4080
jmp 0x8fdd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4340
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8ff4
movq %rax, %rbx
leaq -0x1a8(%rbp), %rdi
callq 0x4080
movq %rbx, %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
xorl %ebx, %ebx
movq %rsi, %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0x44b0
movq %rax, %r12
cmpq $-0x1, %r12
je 0x910d
movq %r12, %rcx
subq %rbx, %rcx
leaq -0x50(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4290
cmpq $0x0, -0x48(%rbp)
je 0x90e8
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x94b8
addq 0x8(%r15), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x44b0
movq %r13, %rdi
movq %rax, %r13
callq 0x4140
movq %r12, %rbx
movq %r13, %r12
jmp 0x90b7
cmpq 0x8(%r14), %rbx
je 0x913b
leaq -0x50(%rbp), %rdi
pushq $-0x1
popq %rcx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4290
leaq -0x50(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x65c4
leaq -0x50(%rbp), %rdi
callq 0x4140
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9152
jmp 0x9160
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4140
jmp 0x9163
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0x68d8
movq %rbx, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movq %rsi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
andq $0x0, 0x10(%rdi)
movq %rdx, -0x38(%rbp)
movsbl (%rdx), %esi
xorl %ebx, %ebx
movq %r14, %rdi
xorl %edx, %edx
callq 0x4310
movq %rax, %r12
leaq -0x58(%rbp), %r13
cmpq $-0x1, %r12
je 0x9206
movq %r12, %rcx
subq %rbx, %rcx
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4290
cmpq $0x0, -0x50(%rbp)
je 0x91de
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x94b8
incq %r12
movq -0x38(%rbp), %rax
movsbl (%rax), %esi
movq %r14, %rdi
movq %r12, %rdx
callq 0x4310
movq %rax, %r15
movq %r13, %rdi
callq 0x4140
movq %r12, %rbx
movq %r15, %r12
jmp 0x91b1
cmpq 0x8(%r14), %rbx
je 0x9234
leaq -0x58(%rbp), %rdi
pushq $-0x1
popq %rcx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4290
leaq -0x58(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x65c4
leaq -0x58(%rbp), %rdi
callq 0x4140
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x924b
jmp 0x9259
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x4140
jmp 0x925c
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0x68d8
movq %rbx, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rsi, %r14
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movq %rdi, -0x30(%rbp)
movups %xmm0, (%rdi)
xorl %eax, %eax
movabsq $0x100002600, %r13      # imm = 0x100002600
leaq -0x50(%rbp), %r12
xorl %r15d, %r15d
xorl %ebx, %ebx
movq 0x8(%r14), %rcx
cmpq %rcx, %rbx
jae 0x93c2
movq (%r14), %rcx
movzbl (%rcx,%rbx), %ecx
cmpq $0x20, %rcx
ja 0x93ae
btq %rcx, %r13
jae 0x93ae
testb $0x1, %al
je 0x93bd
movq %rbx, %rcx
subq %r15, %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4290
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x65c4
movq %r12, %rdi
callq 0x4140
xorl %eax, %eax
jmp 0x93bd
testb $0x1, %al
movzbl %al, %eax
pushq $0x1
popq %rcx
cmovel %ecx, %eax
cmoveq %rbx, %r15
incq %rbx
jmp 0x9362
testb $0x1, %al
je 0x93ee
subq %r15, %rcx
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4290
leaq -0x50(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x65c4
leaq -0x50(%rbp), %rdi
callq 0x4140
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9405
jmp 0x9413
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x4140
jmp 0x9416
movq %rax, %r14
movq -0x30(%rbp), %rdi
callq 0x68d8
movq %r14, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %r15
movq 0x8(%rsi), %rax
movq %rax, -0x30(%rbp)
movq %rdx, %r12
movq 0x8(%rdx), %rbx
xorl %r13d, %r13d
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x44b0
cmpq $-0x1, %rax
je 0x947b
movq %rax, %r13
movq %r15, %rdi
movq %rax, %rsi
movq -0x30(%rbp), %rdx
movq %r12, %rcx
callq 0x40f0
addq %rbx, %r13
jmp 0x944d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
xorl %esi, %esi
movq %rsi, %rdx
cmpq %rsi, %rax
je 0x94af
movsbl (%rcx,%rdx), %edi
addl $-0x30, %edi
leaq 0x1(%rdx), %rsi
cmpl $0xa, %edi
jb 0x9497
cmpq %rdx, %rax
sete %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
leaq 0x8(%rsp), %r12
movq %rax, 0x8(%rsp)
movq (%r15), %rdi
movq 0x8(%r15), %rcx
subq %rdi, %rcx
sarq $0x5, %rcx
cmpq %rcx, %rax
jae 0x2347
shlq $0x5, %rax
addq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x267a
testb %al, %al
je 0x233d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x26ba
movq 0x8(%rsp), %rax
incq %rax
jmp 0x2305
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2a54
movq %r14, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O2/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
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x30(%rsp), %rdi
pushq $0x18
popq %rdx
callq 0x2160
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x30(%rsp), %r14
leaq 0x10(%rsp), %r15
pushq $0x2d
popq %rbp
pushq $0xa
popq %r12
leaq 0xc(%rsp), %r13
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x21a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x23f6
movq %r15, %rdi
xorl %esi, %esi
movl %r12d, %edx
callq 0x26f0
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2c00
jmp 0x23bd
leaq 0x10(%rsp), %rdi
callq 0x2080
leaq 0x30(%rsp), %rdi
callq 0x20d0
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x243d
jmp 0x2426
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x2080
leaq 0x30(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2bcc
movq %r14, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
leal (%rdx,%rsi), %eax
cmpl $0x20, %eax
jae 0x2694
movl %esi, %eax
addq %rax, %rdi
movl %edx, %esi
addq %rdi, %rsi
callq 0x283f
popq %rcx
retq
leaq 0x997(%rip), %rdi       # 0x3032
leaq 0x9aa(%rip), %rsi       # 0x304c
leaq 0x9b0(%rip), %rcx       # 0x3059
pushq $0x1a
popq %rdx
callq 0x20b0
movq %rax, %rdi
callq 0x2850
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
leal (%rbx,%rsi), %eax
cmpl $0x21, %eax
jae 0x2822
movq %rdi, %r14
movl %esi, %eax
addq %rax, %r14
movl %ebx, %esi
addq %r14, %rsi
movq %r14, %rdi
callq 0x2996
movl %eax, %ebp
testb %al, %al
jne 0x2813
leaq 0xf(%rsp), %rdx
movb $0x1, (%rdx)
movq %r14, %rdi
movl %ebx, %esi
callq 0x2a32
xorb $0x1, %bpl
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x86d(%rip), %rdi       # 0x3096
leaq 0x81c(%rip), %rsi       # 0x304c
leaq 0x87b(%rip), %rcx       # 0x30b2
pushq $0xe
popq %rdx
callq 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/vividvilla[P]hackerrank/src/quicksort2.cpp
// Function: quickSortAux(std::vector<int, std::allocator<int>>&, int, int)
void quickSortAux(vector<int> & v, int l, int r) {
    if (l >= r)
        return;

    int p = v[l];
    vector<int> p1;
    vector<int> p2;
    for (int i = l + 1; i <= r; i++) {
        if (v[i] < p)
            p1.push_back(v[i]);
        else if (v[i] > p)
            p2.push_back(v[i]);
    }
    int m = l + p1.size();
    p1.push_back(p);
    p1.insert(p1.end(), p2.begin(), p2.end());

    for (int i = l; i <= r; i++)
        v[i] = p1[i - l];

    quickSortAux(v, l, m - 1);
    quickSortAux(v, m + 1, r);

    for (int i = l; i <= r; i++) {
        cout << v[i];
        if (i + 1 <= r)
            cout << " ";
        else
            cout << endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpl %edx, %esi
jge 0x139b
movq %rdi, %rbx
movl %esi, 0x8(%rsp)
movslq %esi, %rbp
movq (%rdi), %rax
movl (%rax,%rbp,4), %r15d
movl %r15d, 0xc(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
leaq 0x30(%rsp), %rax
andq $0x0, 0x10(%rax)
movaps %xmm0, (%rax)
movl %edx, 0x4(%rsp)
movslq %edx, %r13
leaq 0x4(,%rbp,4), %r14
movq %rbp, %r12
cmpq %r13, %r12
jge 0x12d2
movq (%rbx), %rsi
leaq 0x10(%rsp), %rdi
cmpl %r15d, (%rsi,%r14)
jl 0x12c1
leaq 0x30(%rsp), %rdi
jle 0x12c9
addq %r14, %rsi
callq 0x1478
addq $0x4, %r14
incq %r12
jmp 0x12a7
leaq 0x10(%rsp), %rdi
movq 0x8(%rdi), %r15
subq (%rdi), %r15
leaq 0xc(%rsp), %rsi
callq 0x1478
leaq 0x10(%rsp), %rdi
movq 0x8(%rdi), %rsi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x1496
movl 0x8(%rsp), %esi
shrq $0x2, %r15
addl %esi, %r15d
movq 0x10(%rsp), %rax
movq (%rbx), %rcx
movq %rbp, %rdx
cmpq %r13, %rdx
jg 0x1329
movl (%rax), %edi
movl %edi, (%rcx,%rdx,4)
incq %rdx
addq $0x4, %rax
jmp 0x1316
leal -0x1(%r15), %edx
movq %rbx, %rdi
callq 0x124c
incl %r15d
movq %rbx, %rdi
movl %r15d, %esi
movl 0x4(%rsp), %edx
callq 0x124c
movq 0x2c82(%rip), %r14      # 0x3fd0
leaq 0xcaf(%rip), %r15       # 0x2004
cmpq %r13, %rbp
jg 0x1387
movq (%rbx), %rax
movl (%rax,%rbp,4), %esi
movq %r14, %rdi
callq 0x1100
cmpq %r13, %rbp
jge 0x137a
movq %r14, %rdi
movq %r15, %rsi
callq 0x10b0
jmp 0x1382
movq %r14, %rdi
callq 0x1060
incq %rbp
jmp 0x1355
leaq 0x30(%rsp), %rdi
callq 0x14c2
leaq 0x10(%rsp), %rdi
callq 0x14c2
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13b0
jmp 0x13b0
jmp 0x13b0
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x14c2
leaq 0x10(%rsp), %rdi
callq 0x14c2
movq %rbx, %rdi
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x20(%rsp)
movq 0x2bde(%rip), %rdi      # 0x3fe0
leaq 0xc(%rsp), %rsi
callq 0x1080
xorl %ebp, %ebp
movq 0x2bcb(%rip), %rbx      # 0x3fe0
leaq 0x34(%rsp), %r14
leaq 0x10(%rsp), %r15
cmpl 0xc(%rsp), %ebp
jge 0x143f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1080
movq %r15, %rdi
movq %r14, %rsi
callq 0x1478
incl %ebp
jmp 0x141f
leaq 0x10(%rsp), %rdi
callq 0x13cf
leaq 0x10(%rsp), %rdi
callq 0x14c2
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1462
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x14c2
movq %rbx, %rdi
callq 0x1110
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movl (%rdi), %eax
movl 0x4(%rdi), %ecx
shlq $0x20, %rax
movq %rsp, %r15
movq %rax, (%r15)
movl %ecx, 0x8(%r15)
xorl %eax, %eax
leaq 0x18(%rsp), %r12
testb $0x1, %al
sete %cl
cmpw $-0x2, %ax
setae %al
testb %cl, %al
jne 0x4300
movl (%rsp), %esi
movl %esi, 0x18(%rsp)
movq %rbx, %rdi
callq 0x2564
testb %al, %al
je 0x42f2
movq %r14, %rdi
movq %r12, %rsi
callq 0x3f1a
movq %r15, %rdi
callq 0x3eb2
movzwl (%rsp), %eax
jmp 0x42c4
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
andq $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
pushq $0x1
popq %rsi
shlq %cl, %rsi
leaq 0x18(%rsp), %rdx
andl $0x0, (%rdx)
movw $0x7fff, 0x4(%rdx)      # imm = 0x7FFF
callq 0x4482
movq 0x8(%rsp), %rax
andw $0x0, -0x4(%rax)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x497b
movq 0x28(%rsp), %rcx
addq $-0x4, %rcx
movq %rsp, %r14
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %r8
cmpq %rdx, %rcx
je 0x4381
leaq -0x4(%rcx), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4078
movq %r15, %rcx
jmp 0x435e
movq %rsp, %rsi
movq %rbx, %rdi
movq %rdx, %rcx
callq 0x4078
movq %rsp, %rdi
callq 0x46a4
leaq 0x20(%rsp), %rdi
callq 0x3e7e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x43b1
jmp 0x43b1
movq %rax, %rbx
movq %rsp, %rdi
callq 0x46a4
jmp 0x43c1
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3e7e
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x441f
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x2250
movl %eax, %ebp
movq 0x10(%rbx), %rdi
callq 0x2250
movq %rsp, %rbx
movq %rbx, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x23fc
movq %rbx, %rdi
callq 0x428b
leaq 0x10(%rsp), %rdi
callq 0x2b04
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
leaq 0x10ad(%rip), %rdi      # 0x54d3
callq 0x2230
pushq $0x1
popq %rdi
callq 0x21b0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2b04
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x465d
jae 0x465e
xorl %eax, %eax
retq
movsbl %cl, %edx
shrl %edx
movsbl %sil, %edi
shrl %edi
cmpw %di, %dx
jl 0x465d
jg 0x465b
movswl %cx, %eax
shrl $0x8, %eax
movswl %si, %ecx
shrl $0x8, %ecx
cmpw %cx, %ax
setl %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %esi, 0x4(%rsp)
testl %esi, %esi
je 0x4851
movl %esi, %ebx
movl (%rdi), %ebp
cmpl %esi, %ebp
je 0x4845
addq $0x28, %rdi
leaq 0x4(%rsp), %rsi
callq 0x5af2
cmpl %ebx, %ebp
setne %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x11900(%rip), %rdi     # 0x16158
leaq 0x11900(%rip), %rsi     # 0x1615f
leaq 0x1195b(%rip), %rcx     # 0x161c1
pushq $0x34
popq %rdx
callq 0x4260
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x58, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsi), %r13
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x4450
leaq 0x38(%rbx), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x5b10
movq %rax, %r14
testq %rax, %rax
jne 0x49ea
movl (%r15), %eax
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x8(%rbx), %rbp
movq %rbp, %rdi
callq 0x6876
leaq 0x10(%rbx), %rcx
cmpq %rcx, %rax
jne 0x4a0b
movl 0xc(%rsp), %eax
leaq 0x10(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, 0x8(%rsi)
movq %rbp, %rdi
callq 0x68c8
testb $0x1, %dl
je 0x4a24
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x4450
leaq 0x10(%rsp), %rsi
movq %r15, 0x20(%rsi)
movq %r12, %rdi
callq 0x6a18
movl %edx, %ebp
leaq 0x10(%rsp), %rdi
callq 0x4180
testb $0x1, %bpl
je 0x4a3d
incl (%rbx)
testq %r14, %r14
sete %bl
leaq 0x38(%rsp), %rdi
callq 0x4180
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x117d3(%rip), %rdi     # 0x161e5
leaq 0x11746(%rip), %rsi     # 0x1615f
leaq 0x117e1(%rip), %rcx     # 0x16201
pushq $0x5a
jmp 0x4a54
leaq 0x117f3(%rip), %rdi     # 0x1621e
leaq 0x1172d(%rip), %rsi     # 0x1615f
leaq 0x117c8(%rip), %rcx     # 0x16201
pushq $0x5c
jmp 0x4a54
leaq 0x117df(%rip), %rdi     # 0x16223
leaq 0x11714(%rip), %rsi     # 0x1615f
leaq 0x117af(%rip), %rcx     # 0x16201
pushq $0x5e
popq %rdx
callq 0x4260
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4180
jmp 0x4a72
jmp 0x4a6f
jmp 0x4a6f
jmp 0x4a6f
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x4180
movq %rbx, %rdi
callq 0x4510