LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLDocument::LoadFile(_IO_FILE*)
XMLError XMLDocument::LoadFile( FILE* fp )
{
    Clear();

    fseek( fp, 0, SEEK_SET );
    if ( fgetc( fp ) == EOF && ferror( fp ) != 0 ) {
        SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
        return _errorID;
    }

    fseek( fp, 0, SEEK_END );
    const long filelength = ftell( fp );
    fseek( fp, 0, SEEK_SET );
    if ( filelength == -1L ) {
        SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
        return _errorID;
    }

    const size_t size = filelength;
    if ( size == 0 ) {
        SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
        return _errorID;
    }

    _charBuffer = new char[size+1];
    size_t read = fread( _charBuffer, 1, size, fp );
    if ( read != size ) {
        SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
        return _errorID;
    }

    _charBuffer[size] = 0;

    const char* p = _charBuffer;
    p = XMLUtil::SkipWhiteSpace( p );
    p = XMLUtil::ReadBOM( p, &_writeBOM );
    if ( !p || !*p ) {
        SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
        return _errorID;
    }

    ParseDeep( _charBuffer + (p-_charBuffer), 0 );
    return _errorID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xd310
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4230
movq %r14, %rdi
callq 0x4340
cmpl $-0x1, %eax
je 0xd485
pushq $0x2
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x4230
movq %r14, %rdi
callq 0x4030
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4230
testq %r15, %r15
je 0xd4a7
cmpq $-0x1, %r15
je 0xd495
leaq 0x1(%r15), %rdi
callq 0x4040
movq %rax, 0x78(%rbx)
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x4310
cmpq %r15, %rax
jne 0xd495
movq 0x78(%rbx), %rax
movb $0x0, (%rax,%r15)
movq 0x78(%rbx), %rdi
callq 0xe6ba
leaq 0x58(%rbx), %rsi
movq %rax, %rdi
callq 0xb36e
testq %rax, %rax
je 0xd4a7
cmpb $0x0, (%rax)
je 0xd4a7
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq *0x78(%rcx)
movl 0x5c(%rbx), %eax
jmp 0xd4b8
movq %r14, %rdi
callq 0x4400
testl %eax, %eax
je 0xd3f4
movl $0x5, 0x5c(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
pushq $0x5
jmp 0xd4b7
movl $0xf, 0x5c(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
pushq $0xf
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLDocument::SaveFile(char const*, bool)
XMLError XMLDocument::SaveFile( const char* filename, bool compact )
{
    FILE* fp = callfopen( filename, "w" );
    if ( !fp ) {
        SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, filename, 0 );
        return _errorID;
    }
    SaveFile(fp, compact);
    fclose( fp );
    return _errorID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x36bf(%rip), %rsi      # 0x10b9e
movq %r12, %rdi
callq 0x4240
testq %rax, %rax
je 0xd50b
movq %rax, %r15
movzbl %r14b, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd528
movq %r15, %rdi
callq 0x41f0
movl 0x5c(%rbx), %eax
jmp 0xd51e
movl $0x4, 0x5c(%rbx)
movq %r12, 0x68(%rbx)
andq $0x0, 0x70(%rbx)
pushq $0x4
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLDocument::Parse(char const*, unsigned long)
XMLError XMLDocument::Parse( const char* p, size_t len )
{
	const char* start = p;
    Clear();

    if ( len == 0 || !p || !*p ) {
        SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
        return _errorID;
    }
    if ( len == (size_t)(-1) ) {
        len = strlen( p );
    }
    _charBuffer = new char[ len+1 ];
    memcpy( _charBuffer, p, len );
    _charBuffer[len] = 0;

    p = XMLUtil::SkipWhiteSpace( p );
    p = XMLUtil::ReadBOM( p, &_writeBOM );
    if ( !p || !*p ) {
        SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
        return _errorID;
    }

    ptrdiff_t delta = p - start;	// skip initial whitespace, BOM, etc.
    ParseDeep( _charBuffer+delta, 0 );
    if (_errorID) {
        // clean up now essentially dangling memory.
        // and the parse fail can put objects in the
        // pools that are dead and inaccessible.
        DeleteChildren();
        _elementPool.Clear();
        _attributePool.Clear();
        _textPool.Clear();
        _commentPool.Clear();
    }
    return _errorID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0xd310
testq %r15, %r15
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0xd6e7
cmpb $0x0, (%r14)
je 0xd6e7
cmpq $-0x1, %r15
jne 0xd64a
movq %r14, %rdi
callq 0x40f0
movq %rax, %r15
leaq 0x1(%r15), %rdi
callq 0x4040
movq %rax, %r12
movq %rax, 0x78(%rbx)
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4190
movb $0x0, (%r12,%r15)
movq %r14, %rdi
callq 0xe6ba
leaq 0x58(%rbx), %rsi
movq %rax, %rdi
callq 0xb36e
testq %rax, %rax
je 0xd6e7
cmpb $0x0, (%rax)
je 0xd6e7
subq %r14, %rax
addq 0x78(%rbx), %rax
movq (%rbx), %rcx
xorl %r14d, %r14d
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq *0x78(%rcx)
cmpl $0x0, 0x5c(%rbx)
je 0xd6f9
movq %rbx, %rdi
callq 0xb886
leaq 0x80(%rbx), %rdi
callq 0xe712
leaq 0x100(%rbx), %rdi
callq 0xe74e
leaq 0x180(%rbx), %rdi
callq 0xe78a
leaq 0x200(%rbx), %rdi
callq 0xe7c6
movl 0x5c(%rbx), %r14d
jmp 0xd6f9
movl $0xf, 0x5c(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
pushq $0xf
popq %r14
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLDocument::PrintError() const
void XMLDocument::PrintError() const
{
    if ( _errorID ) {
        static const int LEN = 20;
        char buf1[LEN] = { 0 };
        char buf2[LEN] = { 0 };

        if ( _errorStr1 ) {
            TIXML_SNPRINTF( buf1, LEN, "%s", _errorStr1 );
        }
        if ( _errorStr2 ) {
            TIXML_SNPRINTF( buf2, LEN, "%s", _errorStr2 );
        }

        printf( "XMLDocument error id=%d '%s' str1=%s str2=%s\n",
                _errorID, ErrorName(), buf1, buf2 );
    }
}

// Assembly:
cmpl $0x0, 0x5c(%rdi)
je 0xd7a9
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
andl $0x0, -0x30(%rbp)
xorps %xmm0, %xmm0
andl $0x0, -0x10(%rbp)
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x20(%rbp)
movq 0x68(%rdi), %rcx
testq %rcx, %rcx
je 0xd761
leaq 0x349b(%rip), %rdx      # 0x10bee
leaq -0x40(%rbp), %rdi
pushq $0x14
popq %rsi
xorl %eax, %eax
callq 0x4360
movq 0x70(%rbx), %rcx
testq %rcx, %rcx
je 0xd77f
leaq 0x347d(%rip), %rdx      # 0x10bee
leaq -0x20(%rbp), %rdi
pushq $0x14
popq %rsi
xorl %eax, %eax
callq 0x4360
movl 0x5c(%rbx), %esi
leaq 0xbad7(%rip), %rax      # 0x19260
movq (%rax,%rsi,8), %rdx
leaq 0x340c(%rip), %rdi      # 0x10ba0
leaq -0x40(%rbp), %rcx
leaq -0x20(%rbp), %r8
xorl %eax, %eax
callq 0x4050
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLPrinter::XMLPrinter(_IO_FILE*, bool, int)
XMLPrinter::XMLPrinter( FILE* file, bool compact, int depth ) :
    _elementJustOpened( false ),
    _firstElement( true ),
    _fp( file ),
    _depth( depth ),
    _textDepth( -1 ),
    _processEntities( true ),
    _compactMode( compact )
{
    for( int i=0; i<ENTITY_RANGE; ++i ) {
        _entityFlag[i] = false;
        _restrictedEntityFlag[i] = false;
    }
    for( int i=0; i<NUM_ENTITIES; ++i ) {
        TIXMLASSERT( entities[i].value < ENTITY_RANGE );
        if ( entities[i].value < ENTITY_RANGE ) {
            _entityFlag[ (int)entities[i].value ] = true;
        }
    }
    _restrictedEntityFlag[(int)'&'] = true;
    _restrictedEntityFlag[(int)'<'] = true;
    _restrictedEntityFlag[(int)'>'] = true;	// not required, but consistency is nice
    _buffer.Push( 0 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xb255(%rip), %rax      # 0x18a10
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x10(%rdi)
movq $0xa, 0x68(%rdi)
movb $0x1, %al
movb %al, 0x70(%rdi)
movq %rsi, 0x78(%rdi)
movl %ecx, 0x80(%rdi)
orl $-0x1, 0x84(%rdi)
movb %al, 0x88(%rdi)
movb %dl, 0x89(%rdi)
leaq 0x110(%rdi), %r14
leaq 0x118(%rdi), %rax
movq %rax, 0x110(%rdi)
movq $0x14, 0x12c(%rdi)
pushq $-0x40
popq %rax
xorl %ecx, %ecx
testq %rax, %rax
je 0xd835
movb %cl, 0xca(%rdi,%rax)
movb %cl, 0x10a(%rdi,%rax)
incq %rax
jmp 0xd81d
pushq $0xc
popq %rax
leaq 0xadb1(%rip), %rcx      # 0x185f0
cmpq $0x5c, %rax
je 0xd858
movsbq (%rax,%rcx), %rdx
movb $0x1, 0x8a(%rdi,%rdx)
addq $0x10, %rax
jmp 0xd83f
movb $0x1, %al
movb %al, 0xf0(%rdi)
movb %al, 0x106(%rdi)
movb %al, 0x108(%rdi)
movq %r14, %rdi
xorl %esi, %esi
callq 0xe802
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r14, %rdi
callq 0xe82e
movq %rbx, %rdi
callq 0xe854
movq %r15, %rdi
callq 0x43d0
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLPrinter::Print(char const*, ...)
void XMLPrinter::Print( const char* format, ... )
{
    va_list     va;
    va_start( va, format );

    if ( _fp ) {
        vfprintf( _fp, format, va );
    }
    else {
#if defined(_MSC_VER) && (_MSC_VER >= 1400 )
		#if defined(WINCE)
		int len = 512;
		do {
		    len = len*2;
		    char* str = new char[len]();
			len = _vsnprintf(str, len, format, va);
			delete[] str;
		}while (len < 0);
		#else
        int len = _vscprintf( format, va );
		#endif
#else
        int len = vsnprintf( 0, 0, format, va );
#endif
        // Close out and re-start the va-args
        va_end( va );
        va_start( va, format );
        char* p = _buffer.PushArr( len ) - 1;	// back up over the null terminator.
#if defined(_MSC_VER) && (_MSC_VER >= 1400 )
		#if defined(WINCE)
		_vsnprintf( p, len+1, format, va );
		#else
		vsnprintf_s( p, len+1, _TRUNCATE, format, va );
		#endif
#else
		vsnprintf( p, len+1, format, va );
#endif
    }
    va_end( va );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0xf0(%rbp), %r13
movq %rdx, 0x10(%r13)
movq %rcx, 0x18(%r13)
movq %r8, 0x20(%r13)
movq %r9, 0x28(%r13)
testb %al, %al
je 0xd8fd
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r13, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movabsq $0x3000000010, %r15     # imm = 0x3000000010
movq %r15, -0x40(%rbp)
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
je 0xd92e
leaq -0x40(%rbp), %rdx
movq %rbx, %rsi
callq 0x42c0
jmp 0xd97e
leaq -0x40(%rbp), %rcx
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x4160
movl %eax, %r12d
leaq -0x40(%rbp), %rax
movq %r15, (%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rax, %r15
addq $0x110, %r14            # imm = 0x110
movq %r14, %rdi
movl %r12d, %esi
callq 0xe87a
leaq -0x1(%rax), %rdi
incl %r12d
movslq %r12d, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x4160
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLPrinter::PrintString(char const*, bool)
void XMLPrinter::PrintString( const char* p, bool restricted )
{
    // Look for runs of bytes between entities to print.
    const char* q = p;
    const bool* flag = restricted ? _restrictedEntityFlag : _entityFlag;

    if ( _processEntities ) {
        while ( *q ) {
            // Remember, char is sometimes signed. (How many times has that bitten me?)
            if ( *q > 0 && *q < ENTITY_RANGE ) {
                // Check for entities. If one is found, flush
                // the stream up until the entity, write the
                // entity, and keep looking.
                if ( flag[(unsigned)(*q)] ) {
                    while ( p < q ) {
                        Print( "%c", *p );
                        ++p;
                    }
                    for( int i=0; i<NUM_ENTITIES; ++i ) {
                        if ( entities[i].value == *q ) {
                            Print( "&%s;", entities[i].pattern );
                            break;
                        }
                    }
                    ++p;
                }
            }
            ++q;
        }
    }
    // Flush the remaining string. This will be the entire
    // string if an entity wasn't found.
    if ( !_processEntities || (q-p > 0) ) {
        Print( "%s", p );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x88(%rdi)
jne 0xda7d
shll $0x6, %edx
leaq (%rbx,%rdx), %rcx
addq $0x8a, %rcx
leaq 0x31d1(%rip), %r12      # 0x10bd3
leaq 0xabe7(%rip), %r13      # 0x185f0
movq %r14, %r15
movq %rcx, -0x30(%rbp)
movzbl (%r14), %eax
testq %rax, %rax
je 0xdaa2
cmpb $0x3f, %al
ja 0xda78
cmpb $0x1, (%rcx,%rax)
jne 0xda78
cmpq %r14, %r15
jae 0xda42
movsbl (%r15), %edx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0xd89c
incq %r15
jmp 0xda27
movb (%r14), %al
pushq $-0x10
popq %rcx
leaq 0x10(%rcx), %rdx
cmpq $0x50, %rdx
je 0xda71
cmpb %al, 0x1c(%rcx,%r13)
movq %rdx, %rcx
jne 0xda48
movq (%rdx,%r13), %rdx
movq %rbx, %rdi
leaq 0x316c(%rip), %rsi      # 0x10bd6
xorl %eax, %eax
callq 0xd89c
incq %r15
movq -0x30(%rbp), %rcx
incq %r14
jmp 0xda10
movq %r14, %r15
leaq 0x3167(%rip), %rsi      # 0x10bee
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd89c
testb $0x1, 0x88(%rbx)
je 0xda80
subq %r15, %r14
testq %r14, %r14
jg 0xda80
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLPrinter::PushHeader(bool, bool)
void XMLPrinter::PushHeader( bool writeBOM, bool writeDec )
{
    if ( writeBOM ) {
        static const unsigned char bom[] = { TIXML_UTF_LEAD_0, TIXML_UTF_LEAD_1, TIXML_UTF_LEAD_2, 0 };
        Print( "%s", bom );
    }
    if ( writeDec ) {
        PushDeclaration( "xml version=\"1.0\"" );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rdi, %rbx
testl %esi, %esi
je 0xdaeb
leaq 0x3114(%rip), %rsi      # 0x10bee
leaq 0x314a(%rip), %rdx      # 0x10c2b
movq %rbx, %rdi
xorl %eax, %eax
callq 0xd89c
testb %r14b, %r14b
je 0xdb03
leaq 0x30e4(%rip), %rsi      # 0x10bdb
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xdb08
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLPrinter::PushDeclaration(char const*)
void XMLPrinter::PushDeclaration( const char* value )
{
    if ( _elementJustOpened ) {
        SealElement();
    }
    if ( _textDepth < 0 && !_firstElement && !_compactMode) {
        Print( "\n" );
        PrintSpace( _depth );
    }
    _firstElement = false;
    Print( "<?%s?>", value );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x8(%rdi)
jne 0xdb23
movq %r14, %rdi
callq 0xdc10
cmpl $0x0, 0x84(%r14)
jns 0xdb5f
cmpb $0x0, 0x70(%r14)
jne 0xdb5f
cmpb $0x0, 0x89(%r14)
jne 0xdb5f
leaq 0x2dc8(%rip), %rsi      # 0x1090d
movq %r14, %rdi
xorl %eax, %eax
callq 0xd89c
movl 0x80(%r14), %esi
movq (%r14), %rax
movq %r14, %rdi
callq *0x60(%rax)
movb $0x0, 0x70(%r14)
leaq 0x309f(%rip), %rsi      # 0x10c0a
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0xd89c
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLPrinter::OpenElement(char const*, bool)
void XMLPrinter::OpenElement( const char* name, bool compactMode )
{
    if ( _elementJustOpened ) {
        SealElement();
    }
    _stack.Push( name );

    if ( _textDepth < 0 && !_firstElement && !compactMode ) {
        Print( "\n" );
    }
    if ( !compactMode ) {
        PrintSpace( _depth );
    }

    Print( "<%s", name );
    _elementJustOpened = true;
    _firstElement = false;
    ++_depth;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0xdb9d
movq %rbx, %rdi
callq 0xdc10
leaq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xe8a2
cmpl $0x0, 0x84(%rbx)
jns 0xdbce
testb $0x1, 0x70(%rbx)
jne 0xdbce
testb %r15b, %r15b
jne 0xdbce
leaq 0x2d49(%rip), %rsi      # 0x1090d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xd89c
testb %r15b, %r15b
jne 0xdbe2
movl 0x80(%rbx), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x60(%rax)
leaq 0x3004(%rip), %rsi      # 0x10bed
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xd89c
movb $0x1, 0x8(%rbx)
movb $0x0, 0x70(%rbx)
incl 0x80(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLPrinter::CloseElement(bool)
void XMLPrinter::CloseElement( bool compactMode )
{
    --_depth;
    const char* name = _stack.Pop();

    if ( _elementJustOpened ) {
        Print( "/>" );
    }
    else {
        if ( _textDepth < 0 && !compactMode) {
            Print( "\n" );
            PrintSpace( _depth );
        }
        Print( "</%s>", name );
    }

    if ( _textDepth == _depth ) {
        _textDepth = -1;
    }
    if ( _depth == 0 && !compactMode) {
        Print( "\n" );
    }
    _elementJustOpened = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
decl 0x80(%rdi)
movl %esi, %r14d
movq 0x10(%rdi), %rax
movslq 0x6c(%rdi), %rcx
leaq -0x1(%rcx), %rdx
movl %edx, 0x6c(%rdi)
cmpb $0x1, 0x8(%rdi)
jne 0xddc4
leaq 0x2e3f(%rip), %rsi      # 0x10bf7
movq %rbx, %rdi
xorl %eax, %eax
callq 0xd89c
jmp 0xde0c
movq -0x8(%rax,%rcx,8), %r15
cmpl $0x0, 0x84(%rbx)
setns %al
orb %r14b, %al
jne 0xddf8
leaq 0x2b2e(%rip), %rsi      # 0x1090d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xd89c
movl 0x80(%rbx), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x60(%rax)
leaq 0x2dfb(%rip), %rsi      # 0x10bfa
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xd89c
movl 0x80(%rbx), %eax
cmpl %eax, 0x84(%rbx)
jne 0xde21
orl $-0x1, 0x84(%rbx)
testl %eax, %eax
setne %al
orb %r14b, %al
jne 0xde3c
leaq 0x2adb(%rip), %rsi      # 0x1090d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xd89c
movb $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLPrinter::PushText(char const*, bool)
void XMLPrinter::PushText( const char* text, bool cdata )
{
    _textDepth = _depth-1;

    if ( _elementJustOpened ) {
        SealElement();
    }
    if ( cdata ) {
        Print( "<![CDATA[" );
        Print( "%s", text );
        Print( "]]>" );
    }
    else {
        PrintString( text, true );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movl 0x80(%rdi), %eax
decl %eax
movl %eax, 0x84(%rdi)
cmpb $0x1, 0x8(%rdi)
jne 0xde7b
movq %rbx, %rdi
callq 0xdc10
testb %r15b, %r15b
je 0xdec0
leaq 0x2af7(%rip), %rsi      # 0x1097e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xd89c
leaq 0x2d56(%rip), %rsi      # 0x10bee
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xd89c
leaq 0x2ade(%rip), %rsi      # 0x1098a
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd89c
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd9cc
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLPrinter::PushComment(char const*)
void XMLPrinter::PushComment( const char* comment )
{
    if ( _elementJustOpened ) {
        SealElement();
    }
    if ( _textDepth < 0 && !_firstElement && !_compactMode) {
        Print( "\n" );
        PrintSpace( _depth );
    }
    _firstElement = false;
    Print( "<!--%s-->", comment );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x8(%rdi)
jne 0xe02f
movq %r14, %rdi
callq 0xdc10
cmpl $0x0, 0x84(%r14)
jns 0xe06b
cmpb $0x0, 0x70(%r14)
jne 0xe06b
cmpb $0x0, 0x89(%r14)
jne 0xe06b
leaq 0x28bc(%rip), %rsi      # 0x1090d
movq %r14, %rdi
xorl %eax, %eax
callq 0xd89c
movl 0x80(%r14), %esi
movq (%r14), %rax
movq %r14, %rdi
callq *0x60(%rax)
movb $0x0, 0x70(%r14)
leaq 0x2b89(%rip), %rsi      # 0x10c00
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0xd89c
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLPrinter::PushUnknown(char const*)
void XMLPrinter::PushUnknown( const char* value )
{
    if ( _elementJustOpened ) {
        SealElement();
    }
    if ( _textDepth < 0 && !_firstElement && !_compactMode) {
        Print( "\n" );
        PrintSpace( _depth );
    }
    _firstElement = false;
    Print( "<!%s>", value );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x8(%rdi)
jne 0xe0a3
movq %r14, %rdi
callq 0xdc10
cmpl $0x0, 0x84(%r14)
jns 0xe0df
cmpb $0x0, 0x70(%r14)
jne 0xe0df
cmpb $0x0, 0x89(%r14)
jne 0xe0df
leaq 0x2848(%rip), %rsi      # 0x1090d
movq %r14, %rdi
xorl %eax, %eax
callq 0xd89c
movl 0x80(%r14), %esi
movq (%r14), %rax
movq %r14, %rdi
callq *0x60(%rax)
movb $0x0, 0x70(%r14)
leaq 0x2b26(%rip), %rsi      # 0x10c11
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0xd89c
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.cpp
// Function: tinyxml2::XMLPrinter::VisitEnter(tinyxml2::XMLElement const&, tinyxml2::XMLAttribute const*)
bool XMLPrinter::VisitEnter( const XMLElement& element, const XMLAttribute* attribute )
{
	const XMLElement*	parentElem = element.Parent()->ToElement();
	bool		compactMode = parentElem ? CompactMode(*parentElem) : _compactMode;
    OpenElement( element.Name(), compactMode );
    while ( attribute ) {
        PushAttribute( attribute->Name(), attribute->Value() );
        attribute = attribute->Next();
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%rsi), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
testq %rax, %rax
je 0xe15c
movq (%r14), %rcx
movq %r14, %rdi
movq %rax, %rsi
callq *0x58(%rcx)
movl %eax, %r12d
jmp 0xe163
movb 0x89(%r14), %r12b
addq $0x18, %r15
movq %r15, %rdi
callq 0xb0b2
movzbl %r12b, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0xdb7c
testq %rbx, %rbx
je 0xe1ac
leaq 0x8(%rbx), %rdi
callq 0xb0b2
movq %rax, %r15
leaq 0x20(%rbx), %rdi
callq 0xb0b2
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xdc28
movq 0x38(%rbx), %rbx
jmp 0xe17e
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::StrPair::Set(char*, char*, int)
void Set( char* start, char* end, int flags ) {
        Reset();
        _start  = start;
        _end    = end;
        _flags  = flags | NEEDS_FLUSH;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0xae7a
movq %r15, 0x8(%r12)
movq %r14, 0x10(%r12)
orl $0x100, %ebx            # imm = 0x100
movl %ebx, (%r12)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::XMLUtil::IsNameChar(unsigned char)
inline static bool IsNameChar( unsigned char ch ) {
        return IsNameStartChar( ch )
               || isdigit( ch )
               || ch == '.'
               || ch == '-';
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
callq 0xe2f6
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0xe354
movzbl %bl, %eax
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
setb %cl
addb $-0x2d, %al
cmpb $0x2, %al
setb %al
orb %cl, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::XMLUtil::StringEqual(char const*, char const*, int)
inline static bool StringEqual( const char* p, const char* q, int nChar=INT_MAX )  {
        int n = 0;
        if ( p == q ) {
            return true;
        }
        while( *p && *q && *p == *q && n<nChar ) {
            ++p;
            ++q;
            ++n;
        }
        if ( (n == nChar) || ( *p == 0 && *q == 0 ) ) {
            return true;
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x1, %al
cmpq %rsi, %rdi
je 0xe3af
xorl %ecx, %ecx
movb (%rdi,%rcx), %r8b
testb %r8b, %r8b
je 0xe39d
cmpb (%rsi,%rcx), %r8b
jne 0xe3a9
cmpl %edx, %ecx
jge 0xe3a9
incq %rcx
jmp 0xe385
cmpl %ecx, %edx
je 0xe3af
cmpb $0x0, (%rsi,%rcx)
jne 0xe3ad
jmp 0xe3af
cmpl %ecx, %edx
je 0xe3af
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::MemPoolT<88>::Alloc()
virtual void* Alloc() {
        if ( !_root ) {
            // Need a new block.
            Block* block = new Block();
            _blockPtrs.Push( block );

            for( int i=0; i<COUNT-1; ++i ) {
                block->chunk[i].next = &block->chunk[i+1];
            }
            block->chunk[COUNT-1].next = 0;
            _root = block->chunk;
        }
        void* result = _root;
        _root = _root->next;

        ++_currentAllocs;
        if ( _currentAllocs > _maxAllocs ) {
            _maxAllocs = _currentAllocs;
        }
        _nAllocs++;
        _nUntracked++;
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %r14
testq %r14, %r14
jne 0xe413
movl $0xfd0, %edi            # imm = 0xFD0
callq 0x4200
movq %rax, %r14
movl $0xfd0, %edx            # imm = 0xFD0
movq %rax, %rdi
xorl %esi, %esi
callq 0x4150
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0xeab8
movq %r14, %rax
addq $0x58, %rax
pushq $0x2d
popq %rcx
subq $0x1, %rcx
jb 0xe407
movq %rax, -0x58(%rax)
addq $0x58, %rax
jmp 0xe3f7
andq $0x0, 0xf78(%r14)
movq %r14, 0x68(%rbx)
movq (%r14), %rax
movq %rax, 0x68(%rbx)
movl 0x70(%rbx), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x70(%rbx)
cmpl 0x78(%rbx), %ecx
jl 0xe42b
movl %eax, 0x78(%rbx)
incl 0x74(%rbx)
incl 0x7c(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::MemPoolT<104>::Clear()
void Clear() {
        // Delete the blocks.
        while( !_blockPtrs.Empty()) {
            Block* b  = _blockPtrs.Pop();
            delete b;
        }
        _root = 0;
        _currentAllocs = 0;
        _nAllocs = 0;
        _maxAllocs = 0;
        _nUntracked = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x64(%rbx), %rax
testq %rax, %rax
je 0xe73b
movq 0x8(%rbx), %rcx
leaq -0x1(%rax), %rdx
movl %edx, 0x64(%rbx)
movq -0x8(%rcx,%rax,8), %rdi
callq 0x41c0
jmp 0xe71b
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
andq $0x0, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::DynArray<char, 20>::PushArr(int)
T* PushArr( int count ) {
        EnsureCapacity( _size+count );
        T* ret = &_mem[_size];
        _size += count;
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl 0x20(%rdi), %esi
addl %ebx, %esi
callq 0xea4e
movslq 0x20(%r14), %rax
addl %eax, %ebx
addq (%r14), %rax
movl %ebx, 0x20(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::DynArray<char, 20>::EnsureCapacity(int)
void EnsureCapacity( int cap ) {
        if ( cap > _allocated ) {
            int newAllocated = cap * 2;
            T* newMem = new T[newAllocated];
            memcpy( newMem, _mem, sizeof(T)*_size );	// warning: not using constructors, only works for PODs
            if ( _mem != _pool ) {
                delete [] _mem;
            }
            _mem = newMem;
            _allocated = newAllocated;
        }
    }

// Assembly:
cmpl %esi, 0x1c(%rdi)
jge 0xeab6
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leal (%rsi,%rsi), %r12d
testl %esi, %esi
pushq $-0x1
popq %rax
cmovnsl %r12d, %eax
movslq %eax, %rdi
callq 0x4040
movq %rax, %r14
movq (%rbx), %r15
movslq 0x20(%rbx), %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x4190
leaq 0x8(%rbx), %rax
cmpq %rax, %r15
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0xeaa7
movq %r15, %rdi
callq 0x4280
movq %r14, (%rbx)
movl %r12d, 0x1c(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::MemPoolT<104>::Free(void*)
virtual void Free( void* mem ) {
        if ( !mem ) {
            return;
        }
        --_currentAllocs;
        Chunk* chunk = static_cast<Chunk*>( mem );
#ifdef DEBUG
        memset( chunk, 0xfe, sizeof(Chunk) );
#endif
        chunk->next = _root;
        _root = chunk;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0xed77
decl 0x70(%rdi)
movq 0x68(%rdi), %rax
movq %rax, (%rsi)
movq %rsi, 0x68(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day00/ex00/megaphone.cpp
// Function: main
int main(int argc, char **argv)
{
	if (argc > 1)
	{
		for (int i = 1; i < argc; i++)
			print_capitalized(argv[i]);
		std::cout << std::endl;
	}
	else
		std::cout << "* LOUD AND UNBEARABLE FEEDBACK NOISE *" << std::endl;
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x2, %edi
jl 0x125f
movq %rsi, %rbx
movl %edi, %r15d
pushq $0x1
popq %r12
movq 0x2d8c(%rip), %r14      # 0x3fd8
cmpq %r12, %r15
je 0x1275
movq (%rbx,%r12,8), %rdi
callq 0x11dc
incq %r12
jmp 0x124c
movq 0x2d72(%rip), %rdi      # 0x3fd8
leaq 0xd97(%rip), %rsi       # 0x2004
callq 0x1060
movq %rax, %r14
movq %r14, %rdi
callq 0x1040
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/macfergus[P]baduk/cppsrc/apps/benchmark.cpp
// Function: main
int main() {
    for (int i = 0; i < 10000; ++i) {
        auto game = baduk::newGame(9, 7.5);
        baduk::RandomBot black_bot;
        baduk::RandomBot white_bot;

        while (!game->isOver()) {
            auto next_agent =
                game->nextPlayer() == baduk::Stone::black ?
                    &black_bot :
                    &white_bot;
            const auto next_move = next_agent->selectMove(*game);

            game = game->applyMove(next_move);
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
leaq 0x30(%rsp), %r14
xorl %eax, %eax
leaq 0x8(%rsp), %r15
leaq 0x48(%rsp), %r12
leaq 0x38(%rsp), %r13
leaq 0x28(%rsp), %rbx
leaq 0x18(%rsp), %rbp
cmpl $0x2710, %eax           # imm = 0x2710
je 0x10d32
movl %eax, 0x4(%rsp)
movq %r15, %rdi
pushq $0x9
popq %rsi
movss 0x949(%rip), %xmm0      # 0x115f4
callq 0x3add
movq %r12, %rdi
callq 0x58cc
movq %r13, %rdi
callq 0x58cc
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
testb %al, %al
jne 0x10d1d
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %r12, %rdi
testl %eax, %eax
je 0x10ce4
movq %r13, %rdi
movq 0x8(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
movq %rax, 0x18(%rsp)
movb %dl, 0x20(%rsp)
movq 0x8(%rsp), %rsi
movq (%rsi), %rax
movq %rbx, %rdi
movq %rbp, %rdx
callq *0x28(%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x650a
movq %r14, %rdi
callq 0x3c58
jmp 0x10cc0
leaq 0x10(%rsp), %rdi
callq 0x3c58
movl 0x4(%rsp), %eax
incl %eax
jmp 0x10c8e
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10d4d
jmp 0x10d4d
jmp 0x10d4d
jmp 0x10d4d
jmp 0x10d4d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3c58
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/ebwt_build.cpp
// Function: int parseNumber<int>(int, char const*)
static int parseNumber(T lower, const char *errmsg) {
	char *endPtr= NULL;
	T t = (T)strtol(optarg, &endPtr, 10);
	if (endPtr != NULL) {
		if (t < lower) {
			cerr << errmsg << endl;
			printUsage(cerr);
			throw 1;
		}
		return t;
	}
	cerr << errmsg << endl;
	printUsage(cerr);
	throw 1;
	return -1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
movq %rsi, %rbx
movl %edi, %ebp
movq 0x275b2(%rip), %rax     # 0x31f80
movq (%rax), %rdi
pushq $0xa
popq %rdx
movq %r14, %rsi
callq 0x54d0
cmpq $0x0, (%r14)
je 0xa9ef
cmpl %ebp, %eax
jl 0xa9ef
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x275fa(%rip), %r14     # 0x31ff0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5350
movq %rax, %rdi
callq 0x5180
movq %r14, %rdi
callq 0x9241
pushq $0x4
popq %rdi
callq 0x5190
movl $0x1, (%rax)
movq 0x2753a(%rip), %rsi     # 0x31f60
movq %rax, %rdi
xorl %edx, %edx
callq 0x5630
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./ebwt.h
// Function: fileSize(char const*)
static inline int64_t fileSize(const char* name) {
	std::ifstream f;
	f.open(name, std::ios_base::binary | std::ios_base::in);
	if (!f.good() || f.eof() || !f.is_open()) { return 0; }
	f.seekg(0, std::ios_base::beg);
	std::ifstream::pos_type begin_pos = f.tellg();
	f.seekg(0, std::ios_base::end);
	return static_cast<int64_t>(f.tellg() - begin_pos);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x53e0
pushq $0xc
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x51d0
movq (%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rsp,%rax)
jne 0xabcf
leaq 0x78(%rsp), %rdi
callq 0x50c0
testb %al, %al
je 0xabcf
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x54a0
movq %rsp, %rdi
callq 0x5670
movq %rax, %rbx
movq %rsp, %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x54a0
movq %rsp, %rdi
callq 0x5670
movq %rax, %r14
subq %rbx, %r14
jmp 0xabd2
xorl %r14d, %r14d
movq %rsp, %rdi
callq 0x50f0
movq %r14, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
jmp 0xabec
jmp 0xabec
movq %rax, %rbx
movq %rsp, %rdi
callq 0x50f0
movq %rbx, %rdi
callq 0x5680
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./diff_sample.h
// Function: EList<unsigned int, 128> getDeltaMap<unsigned int>(unsigned int, EList<unsigned int, 128> const&)
static EList<T> getDeltaMap(T v, const EList<T>& dc) {
	// Declare anchor-map-related items
	EList<T> amap;
	size_t amapEnts = 1;
	amap.resizeExact((size_t)v);
	amap.fill(0xffffffff);
	amap[0] = 0;
	// Print out difference cover (and optionally calculate
	// anchor map)
	for(size_t i = 0; i < dc.size(); i++) {
		for(size_t j = i+1; j < dc.size(); j++) {
			assert_gt(dc[j], dc[i]);
			T diffLeft  = dc[j] - dc[i];
			T diffRight = dc[i] + v - dc[j];
			assert_lt(diffLeft, v);
			assert_lt(diffRight, v);
			if(amap[diffLeft] == 0xffffffff) {
				amap[diffLeft] = dc[i];
				amapEnts++;
			}
			if(amap[diffRight] == 0xffffffff) {
				amap[diffRight] = dc[j];
				amapEnts++;
			}
		}
	}
	return amap;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq $0x80, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movl %esi, %esi
callq 0x166ec
leaq 0xc(%rsp), %rsi
orl $-0x1, (%rsi)
movq %rbx, %rdi
callq 0x16730
movq 0x8(%rbx), %rax
andl $0x0, (%rax)
movq 0x18(%r14), %rsi
xorl %eax, %eax
cmpq %rsi, %rax
jae 0xb13a
leaq 0x1(%rax), %rcx
movq %rcx, %rdx
cmpq %rsi, %rdx
jae 0xb135
movq 0x8(%r14), %rsi
movl (%rsi,%rdx,4), %r8d
movl (%rsi,%rax,4), %edi
movl %r8d, %r9d
subl %edi, %r9d
movq 0x8(%rbx), %rsi
cmpl $-0x1, (%rsi,%r9,4)
jne 0xb10e
movl %edi, (%rsi,%r9,4)
movq 0x8(%rbx), %rsi
movl %ebp, %r9d
subl %r8d, %r9d
addl %edi, %r9d
movl %r9d, %edi
cmpl $-0x1, (%rsi,%rdi,4)
jne 0xb12c
movq 0x8(%r14), %r8
movl (%r8,%rdx,4), %r8d
movl %r8d, (%rsi,%rdi,4)
incq %rdx
movq 0x18(%r14), %rsi
jmp 0xb0e5
movq %rcx, %rax
jmp 0xb0d9
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x12c5c
movq %r14, %rdi
callq 0x5680
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./diff_sample.h
// Function: unsigned int myLog2<unsigned int>(unsigned int)
static unsigned int myLog2(T i) {
	assert_eq(1, popCount(i)); // must be power of 2
	for(size_t j = 0; j < sizeof(T)*8; j++) {
		if(i & 1) return (int)j;
		i >>= 1;
	}
	assert(false);
	return 0xffffffff;
}

// Assembly:
xorl %ecx, %ecx
pushq $-0x1
popq %rax
cmpq $0x20, %rcx
je 0xb173
testb $0x1, %dil
jne 0xb171
shrl %edi
incq %rcx
jmp 0xb15e
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./diff_sample.h
// Function: void VSorting_worker<SString<char>>(void*)
static void VSorting_worker(void *vp)
{
        VSortingParam<TStr>* param = (VSortingParam<TStr>*)vp;
	DifferenceCoverSample<TStr>* dcs = param->dcs;
	const TStr& host = dcs->text();
	const size_t hlen = host.length();
	uint32_t v = dcs->v();
	while(true) {
	  size_t cur = 0;
	  {
	    ThreadSafe ts(param->mutex);
	    cur = *(param->cur);
	    (*param->cur)++;
	  }
	  if(cur >= param->boundaries->size()) return;
	  size_t begin = (cur == 0 ? 0 : (*param->boundaries)[cur-1]);
	  size_t end = (*param->boundaries)[cur];
	  assert_leq(begin, end);
	  if(end - begin <= 1) continue;
	  mkeyQSortSuf2(
			host,
			hlen,
			param->sPrimeArr,
			param->sPrimeSz,
			param->sPrimeOrderArr,
			4,
			begin,
			end,
			param->depth,
			v);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %r14
movq 0x18(%r14), %r15
movl 0x8(%rax), %r13d
movq %rsp, %r12
movq 0x38(%rbx), %rdi
movq %rdi, (%rsp)
callq 0x2327a
movq 0x30(%rbx), %rax
movq (%rax), %rbp
leaq 0x1(%rbp), %rcx
movq %rcx, (%rax)
movq %r12, %rdi
callq 0x14b42
movq 0x28(%rbx), %rax
cmpq 0x18(%rax), %rbp
jae 0xb211
movq 0x8(%rax), %rcx
testq %rbp, %rbp
je 0xb1d0
movq -0x8(%rcx,%rbp,8), %rax
jmp 0xb1d2
xorl %eax, %eax
movq (%rcx,%rbp,8), %r10
movq %r10, %rcx
subq %rax, %rcx
cmpq $0x2, %rcx
jb 0xb193
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %r8
subq $0x8, %rsp
movq %r14, %rdi
movq %r15, %rsi
pushq $0x4
popq %r9
pushq $0x0
pushq %r13
pushq 0x20(%rbx)
pushq %r10
pushq %rax
callq 0x16c6f
addq $0x30, %rsp
jmp 0xb193
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./multikey_qsort.h
// Function: void vecswap2<unsigned int, unsigned long>(unsigned int*, unsigned long, unsigned int*, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long)
static inline void vecswap2(TVal* s, size_t slen, TVal* s2, TPos i, TPos j, TPos n, TPos begin, TPos end) {
	assert_geq(i, begin);
	assert_geq(j, begin);
	assert_lt(i, end);
	assert_lt(j, end);
	while(n-- > 0) {
		assert_geq(n, 0);
		TPos a = i+n;
		TPos b = j+n;
		assert_geq(a, begin);
		assert_geq(b, begin);
		assert_lt(a, end);
		assert_lt(b, end);
		swap(s, slen, a, b);
		swap(s2, slen, a, b);
	}
}

// Assembly:
leaq (%rsi,%rcx,4), %rax
addq $-0x4, %rax
leaq (%rdi,%rcx,4), %rcx
addq $-0x4, %rcx
leaq (%rsi,%rdx,4), %rsi
addq $-0x4, %rsi
leaq (%rdi,%rdx,4), %rdx
addq $-0x4, %rdx
movq %r8, %rdi
subq $0x1, %rdi
jb 0xb26e
movl (%rdx,%r8,4), %r9d
movl (%rcx,%r8,4), %r10d
movl %r10d, (%rdx,%r8,4)
movl %r9d, (%rcx,%r8,4)
movl (%rsi,%r8,4), %r9d
movl (%rax,%r8,4), %r10d
movl %r10d, (%rsi,%r8,4)
movl %r9d, (%rax,%r8,4)
movq %rdi, %r8
jmp 0xb243
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./blockwise_sa.h
// Function: void BinarySorting_worker<SString<char>>(void*)
static void BinarySorting_worker(void *vp)
{
	BinarySortingParam<TStr>* param = (BinarySortingParam<TStr>*)vp;
	const TStr& t = *(param->t);
	size_t len = t.length();
	const EList<TIndexOffU>& sampleSuffs = *(param->sampleSuffs);
	EList<TIndexOffU>& bucketSzs = param->bucketSzs;
	EList<TIndexOffU>& bucketReps = param->bucketReps;
	ASSERT_ONLY(size_t numBuckets = bucketSzs.size());
	size_t begin = param->begin;
	size_t end = param->end;
	// Iterate through every suffix in the text, determine which
	// bucket it falls into by doing a binary search across the
	// sorted list of samples, and increment a counter associated
	// with that bucket.  Also, keep one representative for each
	// bucket so that we can split it later.  We loop in ten
	// stretches so that we can print out a helpful progress
	// message.  (This step can take a long time.)
	for(TIndexOffU i = (TIndexOffU)begin; i < end && i < len; i++) {
		TIndexOffU r = binarySASearch(t, i, sampleSuffs);
		if(r == std::numeric_limits<TIndexOffU>::max()) continue; // r was one of the samples
		assert_lt(r, numBuckets);
		bucketSzs[r]++;
		assert_lt(bucketSzs[r], len);
		if(bucketReps[r] == OFF_MASK || (i & 100) == 0) {
			bucketReps[r] = i; // clobbers previous one, but that's OK
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r15
movq 0x18(%r14), %r12
movl 0x50(%rdi), %ebp
movq 0x58(%rdi), %rax
cmpq %r12, %rax
cmovbq %rax, %r12
movl %ebp, %eax
cmpq %rax, %r12
jbe 0xb2cc
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x18d02
cmpl $-0x1, %eax
je 0xb2c8
movl %eax, %eax
movq 0x18(%rbx), %rcx
incl (%rcx,%rax,4)
movq 0x38(%rbx), %rcx
testb $0x64, %bpl
je 0xb2c5
cmpl $-0x1, (%rcx,%rax,4)
jne 0xb2c8
movl %ebp, (%rcx,%rax,4)
incl %ebp
jmp 0xb293
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./timer.h
// Function: Timer::write(std::ostream&)
void write(ostream& out) {
		time_t passed = elapsed();
		// Print the message supplied at construction time followed
		// by time elapsed formatted HH:MM:SS
		time_t hours   = (passed / 60) / 60;
		time_t minutes = (passed / 60) % 60;
		time_t seconds = (passed % 60);
		std::ostringstream oss;
		oss << _msg << setfill ('0') << setw (2) << hours << ":"
			<< setfill ('0') << setw (2) << minutes << ":"
			<< setfill ('0') << setw (2) << seconds << endl;
		out << oss.str().c_str();
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %rbx
movq %rdi, %r13
callq 0xd05e
movq %rax, %rcx
movl $0xe10, %esi            # imm = 0xE10
cqto
idivq %rsi
movq %rax, %r12
pushq $0x3c
popq %rsi
movq %rcx, %rax
cqto
idivq %rsi
movq %rdx, %r14
cqto
idivq %rsi
movq %rdx, %r15
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
callq 0x5490
movq 0x10(%r13), %rsi
movq %rbp, %rdi
callq 0x5350
pushq $0x30
popq %rsi
movq %rax, %rdi
callq 0x5570
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x2, 0x10(%rax,%rcx)
movq %rax, %rdi
movq %r12, %rsi
callq 0x5320
leaq 0x17f83(%rip), %rsi     # 0x24f15
movq %rax, %rdi
callq 0x5350
pushq $0x30
popq %rsi
movq %rax, %rdi
callq 0x5570
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x2, 0x10(%rax,%rcx)
movq %rax, %rdi
movq %r15, %rsi
callq 0x5320
leaq 0x17f4e(%rip), %rsi     # 0x24f15
movq %rax, %rdi
callq 0x5350
pushq $0x30
popq %rsi
movq %rax, %rdi
callq 0x5570
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x2, 0x10(%rax,%rcx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x5320
movq %rax, %rdi
callq 0x5180
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x5580
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x5350
movq %rsp, %rdi
callq 0x5778
leaq 0x20(%rsp), %rdi
callq 0x50e0
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5778
jmp 0xd04c
jmp 0xd049
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x50e0
movq %rbx, %rdi
callq 0x5680
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./filebuf.h
// Function: FileBuf::isGzippedFile(char const*)
static bool isGzippedFile(const char *filename) {
		if (filename == NULL) {
			return false;
		}

		int fd = open(filename, O_RDONLY);
		if (fd == -1) {
			std::cerr << "Unable to open " << filename << std::endl;
			throw 1;
		}

		uint8_t byte1, byte2;

		ssize_t r1 = read(fd, &byte1, sizeof(uint8_t));
		ssize_t r2 = read(fd, &byte2, sizeof(uint8_t));

		if (::close(fd) == -1) {
			std::cerr << "Unable to close " << filename << std::endl;
			throw 1;
		}

		if (r1 == 0 || r2 == 0) {
                        std::cerr << "Unable to read file magic number" << std::endl;
                        return false;
                }

		if (byte1 == 0x1f && byte2 == 0x8b) {
			return true;
		}

		return false;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xee1e
movq %rdi, %rbx
xorl %esi, %esi
xorl %eax, %eax
callq 0x5650
cmpl $-0x1, %eax
je 0xee2b
movl %eax, %ebp
leaq 0x7(%rsp), %rsi
pushq $0x1
popq %r15
movl %eax, %edi
movq %r15, %rdx
callq 0x54f0
movq %rax, %r14
leaq 0x6(%rsp), %rsi
movl %ebp, %edi
movq %r15, %rdx
callq 0x54f0
movq %rax, %r15
movl %ebp, %edi
callq 0x5750
cmpl $-0x1, %eax
je 0xee3b
testq %r14, %r14
je 0xee03
testq %r15, %r15
je 0xee03
movb 0x7(%rsp), %al
xorb $0x1f, %al
movb 0x6(%rsp), %cl
xorb $-0x75, %cl
orb %al, %cl
sete %al
jmp 0xee20
movq 0x231e6(%rip), %rdi     # 0x31ff0
leaq 0x16fd8(%rip), %rsi     # 0x25de9
callq 0x5350
movq %rax, %rdi
callq 0x5180
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x231be(%rip), %rdi     # 0x31ff0
leaq 0x16f8f(%rip), %rsi     # 0x25dc8
jmp 0xee49
movq 0x231ae(%rip), %rdi     # 0x31ff0
leaq 0x16f8f(%rip), %rsi     # 0x25dd8
callq 0x5350
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5350
movq %rax, %rdi
callq 0x5180
pushq $0x4
popq %rdi
callq 0x5190
movl $0x1, (%rax)
movq 0x230ea(%rip), %rsi     # 0x31f60
movq %rax, %rdi
xorl %edx, %edx
callq 0x5630
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./filebuf.h
// Function: BitpairOutFileBuf::BitpairOutFileBuf(char const*)
BitpairOutFileBuf(const char *in) : bpPtr_(0), cur_(0) {
		assert(in != NULL);
		out_ = fopen(in, "wb");
		if(out_ == NULL) {
			std::cerr << "Error: Could not open bitpair-output file " << in << std::endl;
			throw 1;
		}
		memset(buf_, 0, BUF_SZ);
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
andl $0x0, 0x8(%rdi)
movq %rsi, %rbx
andq $0x0, 0x10(%rdi)
leaq 0x16f50(%rip), %rsi     # 0x25e0a
movq %rbx, %rdi
callq 0x53d0
movq %rax, (%r14)
testq %rax, %rax
je 0xeee4
addq $0x18, %r14
movl $0x20000, %edx          # imm = 0x20000
movq %r14, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x51b0
movq 0x23105(%rip), %rdi     # 0x31ff0
leaq 0x16f1b(%rip), %rsi     # 0x25e0d
callq 0x5350
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5350
movq %rax, %rdi
callq 0x5180
pushq $0x4
popq %rdi
callq 0x5190
movl $0x1, (%rax)
movq 0x23041(%rip), %rsi     # 0x31f60
movq %rax, %rdi
xorl %edx, %edx
callq 0x5630
nop