LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf72e
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4230
movq %r14, %rdi
callq 0x4340
cmpl $-0x1, %eax
je 0xf89b
movq %r14, %rdi
xorl %esi, %esi
movl $0x2, %edx
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 0xf8ea
cmpq $-0x1, %r15
je 0xf8ab
leaq 0x1(%r15), %rdi
callq 0x4040
movq %rax, 0x78(%rbx)
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x4300
cmpq %r15, %rax
jne 0xf8ab
movq 0x78(%rbx), %rax
movb $0x0, (%rax,%r15)
movq 0x78(%rbx), %r14
movb (%r14), %al
testb %al, %al
js 0xf8b4
movzbl %al, %edi
callq 0x4060
testl %eax, %eax
je 0xf8b4
movb 0x1(%r14), %al
incq %r14
jmp 0xf882
movq %r14, %rdi
callq 0x4420
testl %eax, %eax
je 0xf818
movl $0x5, 0x5c(%rbx)
jmp 0xf8f1
movb $0x0, 0x58(%rbx)
cmpb $-0x11, (%r14)
jne 0xf8d4
cmpb $-0x45, 0x1(%r14)
jne 0xf8d4
cmpb $-0x41, 0x2(%r14)
jne 0xf8d4
movb $0x1, 0x58(%rbx)
addq $0x3, %r14
cmpb $0x0, (%r14)
je 0xf8ea
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq *0x78(%rax)
jmp 0xf8f8
movl $0xf, 0x5c(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
movl 0x5c(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x336d(%rip), %rsi      # 0x12c8e
movq %r12, %rdi
callq 0x4240
testq %rax, %rax
je 0xf94a
movq %rax, %r15
movzbl %r14b, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf96a
movq %r15, %rdi
callq 0x41e0
jmp 0xf95d
movl $0x4, 0x5c(%rbx)
movq %r12, 0x68(%rbx)
movq $0x0, 0x70(%rbx)
movl 0x5c(%rbx), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r12
movq %rsi, %r14
movq %rdi, %rbx
callq 0xf72e
testq %r12, %r12
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0xfb5a
cmpb $0x0, (%r14)
je 0xfb5a
cmpq $-0x1, %r12
jne 0xfa8c
movq %r14, %rdi
callq 0x4100
movq %rax, %r12
leaq 0x1(%r12), %rdi
callq 0x4040
movq %rax, %r15
movq %rax, 0x78(%rbx)
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4190
movb $0x0, (%r15,%r12)
movb (%r14), %al
movq %r14, %r12
testb %al, %al
js 0xfad5
movq %r14, %r12
movzbl %al, %edi
callq 0x4060
testl %eax, %eax
je 0xfad5
movb 0x1(%r12), %al
incq %r12
testb %al, %al
jns 0xfabd
movb $0x0, 0x58(%rbx)
cmpb $-0x11, (%r12)
jne 0xfaf8
cmpb $-0x45, 0x1(%r12)
jne 0xfaf8
cmpb $-0x41, 0x2(%r12)
jne 0xfaf8
movb $0x1, 0x58(%rbx)
addq $0x3, %r12
cmpb $0x0, (%r12)
je 0xfb5a
subq %r14, %r12
addq %r12, %r15
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq *0x78(%rax)
leaq 0x5c(%rbx), %r14
cmpl $0x0, 0x5c(%rbx)
je 0xfb6c
movq %rbx, %rdi
callq 0xd3cc
leaq 0x80(%rbx), %rdi
callq 0x10cbe
leaq 0x100(%rbx), %rdi
callq 0x10d04
leaq 0x180(%rbx), %rdi
callq 0x10d4a
addq $0x200, %rbx            # imm = 0x200
movq %rbx, %rdi
callq 0x10d90
jmp 0xfb6c
leaq 0x5c(%rbx), %r14
movl $0xf, 0x5c(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
movl (%r14), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfc1f
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, -0x30(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movl %eax, -0x10(%rbp)
movaps %xmm0, -0x20(%rbp)
movq 0x68(%rdi), %rcx
testq %rcx, %rcx
je 0xfbd5
leaq 0x3119(%rip), %rdx      # 0x12cde
leaq -0x40(%rbp), %rdi
movl $0x14, %esi
xorl %eax, %eax
callq 0x4360
movq 0x70(%rbx), %rcx
testq %rcx, %rcx
je 0xfbf5
leaq 0x30f9(%rip), %rdx      # 0x12cde
leaq -0x20(%rbp), %rdi
movl $0x14, %esi
xorl %eax, %eax
callq 0x4360
movl 0x5c(%rbx), %esi
leaq 0xa661(%rip), %rax      # 0x1a260
movq (%rax,%rsi,8), %rdx
leaq 0x3086(%rip), %rdi      # 0x12c90
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_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x9dc8(%rip), %rax      # 0x19a00
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
leaq 0x18(%rdi), %r12
movq %r12, 0x10(%rdi)
movq $0xa, 0x68(%rdi)
movb $0x1, %al
movb %al, 0x70(%rdi)
movq %rsi, 0x78(%rdi)
movl %ecx, 0x80(%rdi)
movl $0xffffffff, 0x84(%rdi) # imm = 0xFFFFFFFF
movb %al, 0x88(%rdi)
movb %dl, 0x89(%rdi)
leaq 0x110(%rdi), %r14
leaq 0x118(%rdi), %r13
movq %r13, 0x110(%rdi)
movq $0x14, 0x12c(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8a(%rdi)
movups %xmm0, 0x9a(%rdi)
movups %xmm0, 0xaa(%rdi)
movups %xmm0, 0xba(%rdi)
movups %xmm0, 0xca(%rdi)
movups %xmm0, 0xda(%rdi)
movups %xmm0, 0xea(%rdi)
movups %xmm0, 0xfa(%rdi)
movl $0xc, %eax
leaq 0x9905(%rip), %rcx      # 0x195e0
movsbq (%rax,%rcx), %rdx
movb $0x1, 0x8a(%rbx,%rdx)
addq $0x10, %rax
cmpq $0x5c, %rax
jne 0xfcdb
movb $0x1, %al
movb %al, 0xf0(%rbx)
movb %al, 0x106(%rbx)
movb %al, 0x108(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x10f84
movq 0x110(%rbx), %rax
movslq 0x130(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x130(%rbx)
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r14), %rdi
cmpq %r13, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0xfd58
callq 0x4280
movq 0x10(%rbx), %rdi
cmpq %r12, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0xfd71
callq 0x4280
movq %r15, %rdi
callq 0x43d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfddb
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 0xfe0c
leaq -0x40(%rbp), %rdx
movq %rbx, %rsi
callq 0x42b0
jmp 0xfe7c
leaq -0x40(%rbp), %rcx
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x4150
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
leaq 0x110(%r14), %rdi
movl 0x130(%r14), %esi
addl %r12d, %esi
callq 0x10f84
movq 0x110(%r14), %rax
movslq 0x130(%r14), %rcx
leal (%rcx,%r12), %edx
movl %edx, 0x130(%r14)
leaq (%rax,%rcx), %rdi
decq %rdi
incl %r12d
movslq %r12d, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x4150
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdi, %r14
cmpb $0x1, 0x88(%rdi)
jne 0xff7b
movb (%rbx), %al
testb %al, %al
je 0xff7b
shll $0x6, %edx
leaq (%r14,%rdx), %rcx
addq $0x8a, %rcx
leaq 0x2dbf(%rip), %r15      # 0x12cc3
leaq 0x96d5(%rip), %r12      # 0x195e0
movq %rbx, %r13
movq %rcx, -0x30(%rbp)
cmpb $0x3f, %al
ja 0xff6e
movzbl %al, %eax
cmpb $0x1, (%rcx,%rax)
jne 0xff6e
cmpq %r13, %rbx
jae 0xff39
movsbl (%rbx), %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xfd7a
incq %rbx
jmp 0xff1f
movb (%r13), %al
xorl %ecx, %ecx
cmpb %al, 0xc(%rcx,%r12)
je 0xff52
addq $0x10, %rcx
cmpq $0x50, %rcx
jne 0xff3f
jmp 0xff67
movq (%rcx,%r12), %rdx
movq %r14, %rdi
leaq 0x2d66(%rip), %rsi      # 0x12cc6
xorl %eax, %eax
callq 0xfd7a
incq %rbx
movq -0x30(%rbp), %rcx
movb 0x1(%r13), %al
incq %r13
testb %al, %al
jne 0xff12
jmp 0xff7e
movq %rbx, %r13
cmpb $0x1, 0x88(%r14)
jne 0xff9f
subq %rbx, %r13
testq %r13, %r13
jg 0xff9f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d38(%rip), %rsi      # 0x12cde
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xfd7a
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xffeb
leaq 0x2d04(%rip), %rsi      # 0x12cde
leaq 0x298b(%rip), %rdx      # 0x1296c
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfd7a
testb %r14b, %r14b
je 0x10003
leaq 0x2cd4(%rip), %rsi      # 0x12ccb
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x10008
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10031
movb $0x0, 0x8(%r14)
leaq 0x2cd1(%rip), %rsi      # 0x12cf8
movq %r14, %rdi
xorl %eax, %eax
callq 0xfd7a
cmpl $0x0, 0x84(%r14)
jns 0x1006d
cmpb $0x0, 0x70(%r14)
jne 0x1006d
cmpb $0x0, 0x89(%r14)
jne 0x1006d
leaq 0x28e2(%rip), %rsi      # 0x12935
movq %r14, %rdi
xorl %eax, %eax
callq 0xfd7a
movl 0x80(%r14), %esi
movq (%r14), %rax
movq %r14, %rdi
callq *0x60(%rax)
movb $0x0, 0x70(%r14)
leaq 0x2c81(%rip), %rsi      # 0x12cfa
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0xfd7a
// File: /workspace/github_cpp_makefile_star2_O1/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 0x100b8
movb $0x0, 0x8(%rbx)
leaq 0x2c4a(%rip), %rsi      # 0x12cf8
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfd7a
leaq 0x10(%rbx), %rdi
movl 0x6c(%rbx), %esi
incl %esi
callq 0x112f8
movq 0x10(%rbx), %rax
movslq 0x6c(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x6c(%rbx)
movq %r14, (%rax,%rcx,8)
cmpl $0x0, 0x84(%rbx)
jns 0x100fd
testb $0x1, 0x70(%rbx)
jne 0x100fd
testb %r15b, %r15b
jne 0x100fd
leaq 0x2842(%rip), %rsi      # 0x12935
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfd7a
testb %r15b, %r15b
jne 0x10111
movl 0x80(%rbx), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x60(%rax)
leaq 0x2bc5(%rip), %rsi      # 0x12cdd
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xfd7a
movb $0x1, 0x8(%rbx)
movb $0x0, 0x70(%rbx)
incl 0x80(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1031a
leaq 0x29d9(%rip), %rsi      # 0x12ce7
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfd7a
jmp 0x10362
movq -0x8(%rax,%rcx,8), %r15
cmpl $0x0, 0x84(%rbx)
setns %al
orb %r14b, %al
jne 0x1034e
leaq 0x2600(%rip), %rsi      # 0x12935
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfd7a
movl 0x80(%rbx), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x60(%rax)
leaq 0x2995(%rip), %rsi      # 0x12cea
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xfd7a
movl 0x80(%rbx), %eax
cmpl %eax, 0x84(%rbx)
jne 0x1037a
movl $0xffffffff, 0x84(%rbx) # imm = 0xFFFFFFFF
testl %eax, %eax
setne %al
orb %r14b, %al
jne 0x10395
leaq 0x25aa(%rip), %rsi      # 0x12935
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfd7a
movb $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x103e0
movb $0x0, 0x8(%rbx)
leaq 0x2922(%rip), %rsi      # 0x12cf8
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfd7a
testb %r15b, %r15b
je 0x10425
leaq 0x2682(%rip), %rsi      # 0x12a6e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfd7a
leaq 0x28e1(%rip), %rsi      # 0x12cde
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xfd7a
leaq 0x2669(%rip), %rsi      # 0x12a7a
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xfd7a
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xfec4
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x105db
movb $0x0, 0x8(%r14)
leaq 0x2727(%rip), %rsi      # 0x12cf8
movq %r14, %rdi
xorl %eax, %eax
callq 0xfd7a
cmpl $0x0, 0x84(%r14)
jns 0x10617
cmpb $0x0, 0x70(%r14)
jne 0x10617
cmpb $0x0, 0x89(%r14)
jne 0x10617
leaq 0x2338(%rip), %rsi      # 0x12935
movq %r14, %rdi
xorl %eax, %eax
callq 0xfd7a
movl 0x80(%r14), %esi
movq (%r14), %rax
movq %r14, %rdi
callq *0x60(%rax)
movb $0x0, 0x70(%r14)
leaq 0x26cd(%rip), %rsi      # 0x12cf0
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0xfd7a
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1065d
movb $0x0, 0x8(%r14)
leaq 0x26a5(%rip), %rsi      # 0x12cf8
movq %r14, %rdi
xorl %eax, %eax
callq 0xfd7a
cmpl $0x0, 0x84(%r14)
jns 0x10699
cmpb $0x0, 0x70(%r14)
jne 0x10699
cmpb $0x0, 0x89(%r14)
jne 0x10699
leaq 0x22b6(%rip), %rsi      # 0x12935
movq %r14, %rdi
xorl %eax, %eax
callq 0xfd7a
movl 0x80(%r14), %esi
movq (%r14), %rax
movq %r14, %rdi
callq *0x60(%rax)
movb $0x0, 0x70(%r14)
leaq 0x265c(%rip), %rsi      # 0x12d01
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0xfd7a
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10716
movq (%r14), %rcx
movq %r14, %rdi
movq %rax, %rsi
callq *0x58(%rcx)
movl %eax, %r12d
jmp 0x1071d
movb 0x89(%r14), %r12b
addq $0x18, %r15
movq %r15, %rdi
callq 0xc988
movzbl %r12b, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x1008a
testq %rbx, %rbx
je 0x10766
leaq 0x8(%rbx), %rdi
callq 0xc988
movq %rax, %r15
leaq 0x20(%rbx), %rdi
callq 0xc988
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x10156
movq 0x38(%rbx), %rbx
jmp 0x10738
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rsi, %r12
movq %rdi, %r14
testb $0x2, 0x1(%rdi)
je 0x108b8
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x108b8
callq 0x4280
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movq %r12, 0x8(%r14)
movq %r15, 0x10(%r14)
orl $0x100, %ebx            # imm = 0x100
movl %ebx, (%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x0, 0x68(%rdi)
jne 0x1094f
movl $0xfd0, %edi            # imm = 0xFD0
callq 0x41f0
movq %rax, %r14
movl $0xfd0, %edx            # imm = 0xFD0
movq %rax, %rdi
xorl %esi, %esi
callq 0x4140
leaq 0x8(%rbx), %rdi
movl 0x64(%rbx), %esi
incl %esi
callq 0x10ff0
movq 0x8(%rbx), %rax
movslq 0x64(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x64(%rbx)
movq %r14, (%rax,%rcx,8)
movq %r14, %rax
addq $0x58, %rax
movl $0x2d, %ecx
movq %rax, -0x58(%rax)
addq $0x58, %rax
decq %rcx
jne 0x10933
movq $0x0, 0xf78(%r14)
movq %r14, 0x68(%rbx)
movq 0x68(%rbx), %rax
movq (%rax), %rcx
movq %rcx, 0x68(%rbx)
movl 0x70(%rbx), %edx
leal 0x1(%rdx), %ecx
movl %ecx, 0x70(%rbx)
cmpl 0x78(%rbx), %edx
jl 0x1096b
movl %ecx, 0x78(%rbx)
incl 0x74(%rbx)
incl 0x7c(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl 0x64(%rdi), %eax
testl %eax, %eax
je 0x10cee
movq 0x8(%rbx), %rcx
leal -0x1(%rax), %edx
movl %edx, 0x64(%rbx)
cltq
movq -0x8(%rcx,%rax,8), %rdi
testq %rdi, %rdi
je 0x10ce9
callq 0x41c0
movl 0x64(%rbx), %eax
jmp 0x10cca
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
movq $0x0, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10fee
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leal (%rsi,%rsi), %r12d
testl %esi, %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
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 0x10fdf
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_O1/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 0x11207
decl 0x70(%rdi)
movq 0x68(%rdi), %rax
movq %rax, (%rsi)
movq %rsi, 0x68(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
cmpl $0x2, %edi
jl 0x1281
movq %rsi, %rbx
movl %edi, %r14d
movl $0x1, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x11ec
incq %r15
cmpq %r15, %r14
jne 0x126e
jmp 0x1299
movq 0x2d50(%rip), %rdi      # 0x3fd8
leaq 0xd75(%rip), %rsi       # 0x2004
movl $0x26, %edx
callq 0x1080
movq 0x2d38(%rip), %rbx      # 0x3fd8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x68, %rsp
xorl %ecx, %ecx
leaq 0x5985(%rip), %rax      # 0x16d10
addq $0x10, %rax
movq %rax, 0x30(%rsp)
leaq 0x58(%rsp), %r13
leaq 0x48(%rsp), %rbx
leaq 0x20(%rsp), %r14
leaq 0x38(%rsp), %r15
movabsq $0x20c49ba5e353f7cf, %r12 # imm = 0x20C49BA5E353F7CF
movl %ecx, 0x1c(%rsp)
leaq 0x8(%rsp), %rdi
movl $0x9, %esi
movss 0x123c(%rip), %xmm0     # 0x12604
callq 0x3ba5
movq 0x30(%rsp), %rbp
movq %rbp, 0x58(%rsp)
callq 0x3040
imulq %r12
movq %rdx, %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rcx
addq %rax, %rcx
movq %rcx, %rax
movabsq $0x200000005, %rdx      # imm = 0x200000005
mulq %rdx
movq %rcx, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x1e, %rax
movq %rax, %rdx
shlq $0x1f, %rdx
subq %rdx, %rax
leaq (%rcx,%rax), %rdx
cmpq $0x1, %rdx
adcq %rcx, %rax
movq %rax, 0x60(%rsp)
movq %rbp, 0x48(%rsp)
callq 0x3040
imulq %r12
movq %rdx, %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rcx
addq %rax, %rcx
movq %rcx, %rax
movabsq $0x200000005, %rdx      # imm = 0x200000005
mulq %rdx
movq %rcx, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x1e, %rax
movq %rax, %rdx
shlq $0x1f, %rdx
subq %rdx, %rax
leaq (%rcx,%rax), %rdx
cmpq $0x1, %rdx
adcq %rcx, %rax
movq %rax, 0x50(%rsp)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
testb %al, %al
jne 0x114fc
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %r13, %rdi
testl %eax, %eax
je 0x114a6
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
movq %rax, 0x38(%rsp)
movb %dl, 0x40(%rsp)
movq 0x8(%rsp), %rsi
movq (%rsi), %rax
movq %r14, %rdi
movq %r15, %rdx
callq *0x28(%rax)
movaps 0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x20(%rsp)
movq 0x10(%rsp), %rdi
movups %xmm0, 0x8(%rsp)
testq %rdi, %rdi
je 0x114eb
callq 0x3cea
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x11482
callq 0x3cea
jmp 0x11482
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
movl 0x1c(%rsp), %ebp
je 0x1150f
callq 0x3cea
incl %ebp
cmpl $0x2710, %ebp           # imm = 0x2710
movl %ebp, %ecx
jne 0x113b2
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11536
jmp 0x11536
jmp 0x11536
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x11548
callq 0x3cea
movq %rbx, %rdi
callq 0x3290
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movq 0x2e039(%rip), %rax     # 0x3af70
movq (%rax), %rdi
movq %r14, %rsi
movl $0xa, %edx
callq 0x54d0
cmpq $0x0, (%r14)
je 0xcf5a
cmpl %ebp, %eax
jl 0xcf5a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x2e08f(%rip), %r14     # 0x3aff0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5350
movq %rax, %rdi
callq 0x5170
movq %r14, %rdi
callq 0xaa4a
movl $0x4, %edi
callq 0x5180
movl $0x1, (%rax)
movq 0x2dfb5(%rip), %rsi     # 0x3af48
movq %rax, %rdi
xorl %edx, %edx
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O1/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 0x53f0
movq %r14, %rdi
movq %rbx, %rsi
movl $0xc, %edx
callq 0x51d0
movq (%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rsp,%rax)
jne 0xd095
leaq 0x78(%rsp), %rdi
callq 0x50b0
testb %al, %al
je 0xd095
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x54a0
movq %rsp, %rdi
callq 0x5690
movq %rax, %rbx
movq %rsp, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x54a0
movq %rsp, %rdi
callq 0x5690
movq %rax, %r14
subq %rbx, %r14
jmp 0xd098
xorl %r14d, %r14d
movq %rsp, %rdi
callq 0x50d0
movq %r14, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
jmp 0xd0b2
jmp 0xd0b2
movq %rax, %rbx
movq %rsp, %rdi
callq 0x50d0
movq %rbx, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, (%rdi)
leaq 0x8(%rdi), %r15
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movq $0x80, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movl %esi, %esi
callq 0x1cbe2
cmpq $0x0, 0x18(%r14)
je 0xd659
xorl %eax, %eax
movq 0x8(%r14), %rcx
movl $0xffffffff, (%rcx,%rax,4) # imm = 0xFFFFFFFF
incq %rax
cmpq 0x18(%r14), %rax
jb 0xd645
movq (%r15), %rax
movl $0x0, (%rax)
cmpq $0x0, 0x18(%rbx)
je 0xd6c8
xorl %eax, %eax
movq %rax, %rcx
incq %rax
cmpq 0x18(%rbx), %rax
jae 0xd6c2
movq %rax, %rdx
movq 0x8(%rbx), %rsi
movl (%rsi,%rdx,4), %edi
movl (%rsi,%rcx,4), %esi
movl %edi, %r8d
subl %esi, %r8d
movq (%r15), %r9
cmpl $-0x1, (%r9,%r8,4)
jne 0xd698
movl %esi, (%r9,%r8,4)
movl %ebp, %r8d
subl %edi, %r8d
addl %esi, %r8d
movl %r8d, %esi
movq (%r15), %rdi
cmpl $-0x1, (%rdi,%rsi,4)
jne 0xd6b9
movq 0x8(%rbx), %r8
movl (%r8,%rdx,4), %r8d
movl %r8d, (%rdi,%rsi,4)
incq %rdx
cmpq 0x18(%rbx), %rdx
jb 0xd67a
cmpq 0x18(%rbx), %rax
jb 0xd66b
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r15), %rdi
testq %rdi, %rdi
je 0xd6f5
callq 0x5450
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq %rbx, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x38(%rbx), %r12
movq %r12, %rdi
callq 0x2d29c
movq 0x30(%rbx), %rax
movq (%rax), %rbp
leaq 0x1(%rbp), %rcx
movq %rcx, (%rax)
movq %r12, %rdi
callq 0x2d2d8
movq 0x28(%rbx), %rcx
movl $0x1, %edx
cmpq 0x18(%rcx), %rbp
jae 0xd7a6
testq %rbp, %rbp
je 0xd75a
movq 0x8(%rcx), %rax
movq -0x8(%rax,%rbp,8), %rax
jmp 0xd75c
xorl %eax, %eax
movq 0x8(%rcx), %rcx
movq (%rcx,%rbp,8), %r10
movq %r10, %rcx
subq %rax, %rcx
movl $0x2, %edx
cmpq $0x2, %rcx
jb 0xd7a6
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %r8
subq $0x8, %rsp
movq %r14, %rdi
movq %r15, %rsi
movl $0x4, %r9d
pushq $0x0
pushq %r13
pushq 0x20(%rbx)
pushq %r10
pushq %rax
callq 0x1d36c
addq $0x30, %rsp
xorl %edx, %edx
testb $0x1, %dl
je 0xd719
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0xdcfa
// File: /workspace/github_cpp_makefile_star2_O1/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 0x127b1
movq %rdi, %rbx
xorl %esi, %esi
xorl %eax, %eax
callq 0x5670
cmpl $-0x1, %eax
je 0x127be
movl %eax, %ebp
leaq 0x7(%rsp), %rsi
movl $0x1, %edx
movl %eax, %edi
callq 0x54f0
movq %rax, %r14
leaq 0x6(%rsp), %rsi
movl $0x1, %edx
movl %ebp, %edi
callq 0x54f0
movq %rax, %r15
movl %ebp, %edi
callq 0x5760
cmpl $-0x1, %eax
je 0x127ce
testq %r14, %r14
je 0x1276f
testq %r15, %r15
je 0x1276f
movb 0x7(%rsp), %al
xorb $0x1f, %al
movb 0x6(%rsp), %cl
xorb $-0x75, %cl
orb %al, %cl
sete %al
jmp 0x127b3
movq 0x2887a(%rip), %rbx     # 0x3aff0
leaq 0x1d659(%rip), %rsi     # 0x2fdd6
movl $0x20, %edx
movq %rbx, %rdi
callq 0x5400
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5340
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x51f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x2882b(%rip), %rdi     # 0x3aff0
leaq 0x1d5e9(%rip), %rsi     # 0x2fdb5
jmp 0x127dc
movq 0x2881b(%rip), %rdi     # 0x3aff0
leaq 0x1d5e9(%rip), %rsi     # 0x2fdc5
callq 0x5350
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5350
movq %rax, %rdi
callq 0x5170
movl $0x4, %edi
callq 0x5180
movl $0x1, (%rax)
movq 0x2873d(%rip), %rsi     # 0x3af48
movq %rax, %rdi
xorl %edx, %edx
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rsi, %rbx
movq %rdi, %r14
movl $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x1d5c1(%rip), %rsi     # 0x2fdf7
movq %rbx, %rdi
callq 0x53d0
movq %rax, (%r14)
testq %rax, %rax
je 0x12860
addq $0x18, %r14
movl $0x20000, %edx          # imm = 0x20000
movq %r14, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x51b0
movq 0x28789(%rip), %rdi     # 0x3aff0
leaq 0x1d58c(%rip), %rsi     # 0x2fdfa
callq 0x5350
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5350
movq %rax, %rdi
callq 0x5170
movl $0x4, %edi
callq 0x5180
movl $0x1, (%rax)
movq 0x286ab(%rip), %rsi     # 0x3af48
movq %rax, %rdi
xorl %edx, %edx
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./filebuf.h
// Function: BitpairOutFileBuf::close()
void close() {
		if(cur_ > 0 || bpPtr_ > 0) {
			if(bpPtr_ == 0) cur_--;
			if(!fwrite((const void *)buf_, cur_ + 1, 1, out_)) {
				std::cerr << "Error writing to the reference index file (.4.ebwt)" << std::endl;
				throw 1;
			}
		}
		fclose(out_);
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
setne %dl
movl 0x8(%rdi), %ecx
testl %ecx, %ecx
setg %sil
orb %dl, %sil
cmpb $0x1, %sil
jne 0x12956
testl %ecx, %ecx
jne 0x12939
decq %rax
movq %rax, 0x10(%rbx)
leaq 0x18(%rbx), %rdi
movq (%rbx), %rcx
movq 0x10(%rbx), %rsi
incq %rsi
movl $0x1, %edx
callq 0x5740
testq %rax, %rax
je 0x1295f
movq (%rbx), %rdi
popq %rbx
jmp 0x5360
movq 0x2868a(%rip), %rdi     # 0x3aff0
leaq 0x1d4b8(%rip), %rsi     # 0x2fe25
callq 0x5350
movq %rax, %rdi
callq 0x5170
movl $0x4, %edi
callq 0x5180
movl $0x1, (%rax)
movq 0x285b7(%rip), %rsi     # 0x3af48
movq %rax, %rdi
xorl %edx, %edx
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./ebwt.h
// Function: SString<char> Ebwt::join<SString<char>>(EList<FileBuf*, 128>&, EList<RefRecord, 128>&, unsigned int, RefReadInParams const&, unsigned int)
TStr Ebwt::join(EList<FileBuf*>& l,
		EList<RefRecord>& szs,
		TIndexOffU sztot,
		const RefReadInParams& refparams,
		uint32_t seed)
{
	RandomSource rand; // reproducible given same seed
	rand.init(seed);
	RefReadInParams rpcp = refparams;
	TStr ret;
	size_t guessLen = sztot;
	ret.resize(guessLen);
	TIndexOffU dstoff = 0;
	ASSERT_ONLY(size_t szsi = 0);
	for(size_t i = 0; i < l.size(); i++) {
		// For each sequence we can pull out of istream l[i]...
		assert(!l[i]->eof());
		bool first = true;
		while(!l[i]->eof()) {
			RefRecord rec = fastaRefReadAppend(*l[i], first, ret, dstoff, rpcp);
#ifndef ACCOUNT_FOR_ALL_GAP_REFS
			if(rec.first && rec.len == 0) rec.first = false;
#endif
			first = false;
			size_t bases = rec.len;
			assert_eq(rec.off, szs[szsi].off);
			assert_eq(rec.len, szs[szsi].len);
			assert_eq(rec.first, szs[szsi].first);
			ASSERT_ONLY(szsi++);
			if(bases == 0) continue;
		}
	}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%r8), %rax
movq %rax, 0x8(%rsp)
leaq 0x271ca(%rip), %rax     # 0x3aac0
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
movl %ecx, %esi
callq 0xdd30
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x18(%r14)
je 0x13969
xorl %r13d, %r13d
leaq 0x4(%rsp), %r15
leaq 0x8(%rsp), %r12
movb $0x1, %al
movq 0x8(%r14), %rcx
movq (%rcx,%r13,8), %rdi
movq 0x20(%rdi), %rcx
cmpq 0x28(%rdi), %rcx
jne 0x13945
testb $0x1, 0x30(%rdi)
jne 0x13960
movzbl %al, %esi
andl $0x1, %esi
movq %rbx, %rdx
movq %r15, %rcx
movq %r12, %r8
xorl %r9d, %r9d
callq 0xd0c5
xorl %eax, %eax
jmp 0x1392d
incq %r13
cmpq 0x18(%r14), %r13
jb 0x1392b
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1397c
movq %rax, %r14
movq %rbx, %rdi
callq 0xdd8e
movq %r14, %rdi
callq 0x56a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/BenLangmead[P]bowtie/./sstring.h
// Function: SString<char>::toZBufXForm(char const*) const
const char* toZBufXForm(const char *xform) const {
		ASSERT_ONLY(size_t xformElts = strlen(xform));
		// Lazily allocate space for print buffer
		if(printcs_ == NULL) {
			const_cast<char*&>(printcs_) = new char[len_+1];
		}
		char* printcs = const_cast<char*>(printcs_);
		assert(printcs != NULL);
		for(size_t i = 0; i < len_; i++) {
			assert_lt(cs_[i], (int)xformElts);
			printcs[i] = xform[(int)cs_[i]];
		}
		printcs[len_] = 0;
		return printcs_;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
jne 0x139b1
movq 0x18(%rbx), %rdi
incq %rdi
callq 0x5030
movq %rax, 0x10(%rbx)
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rdx
testq %rdx, %rdx
je 0x139dc
xorl %ecx, %ecx
movq 0x8(%rbx), %rdx
movsbq (%rdx,%rcx), %rdx
movb (%r14,%rdx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
movq 0x18(%rbx), %rdx
cmpq %rdx, %rcx
jb 0x139c0
movb $0x0, (%rax,%rdx)
movq 0x10(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq