LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLRealloc
void * CPLRealloc( void * pData, size_t nNewSize )

{
    void        *pReturn;

    if ( nNewSize == 0 )
    {
        VSIFree(pData);
        return NULL;
    }

    if( (ssize_t)nNewSize < 0 )
    {
        CPLError( CE_Failure, CPLE_AppDefined,
                  "CPLRealloc(%ld): Silly size requested.\n",
                  (long)nNewSize );
        return NULL;
    }
    
    if( pData == NULL )
        pReturn = VSIMalloc( nNewSize );
    else
        pReturn = VSIRealloc( pData, nNewSize );
    
    if( pReturn == NULL )
    {
        CPLError( CE_Fatal, CPLE_OutOfMemory,
                  "CPLRealloc(): Out of memory allocating %ld bytes.\n",
                  (long)nNewSize );
    }

    return pReturn;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x2e16
movq %rsi, %rbx
js 0x2e20
testq %rdi, %rdi
je 0x2e36
movq %rbx, %rsi
callq 0x7018
jmp 0x2e3e
callq 0x701d
xorl %r14d, %r14d
jmp 0x2e61
leaq 0xd4d3(%rip), %rdx      # 0x102fa
xorl %r14d, %r14d
movl $0x3, %edi
movl $0x1, %esi
jmp 0x2e57
movq %rbx, %rdi
callq 0x7013
movq %rax, %r14
testq %rax, %rax
jne 0x2e61
leaq 0xd4d5(%rip), %rdx      # 0x10322
movl $0x4, %edi
movl $0x2, %esi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x46dc
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLStrdup
char *CPLStrdup( const char * pszString )

{
    char        *pszReturn;

    if( pszString == NULL )
        pszString = "";

    pszReturn = VSIStrdup( pszString );
        
    if( pszReturn == NULL )
    {
        CPLError( CE_Fatal, CPLE_OutOfMemory,
                  "CPLStrdup(): Out of memory allocating %d bytes.\n",
                  strlen(pszString) );
        
    }
    
    return( pszReturn );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
leaq 0xe13a(%rip), %r14      # 0x10fb4
cmovneq %rdi, %r14
movq %r14, %rdi
callq 0x7027
movq %rax, %rbx
testq %rax, %rax
jne 0x2eb1
movq %r14, %rdi
callq 0x2120
leaq 0xd4b8(%rip), %rdx      # 0x10355
movl $0x4, %edi
movl $0x2, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x46dc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLReadLine
const char *CPLReadLine( FILE * fp )

{
    char *pszRLBuffer = CPLReadLineBuffer(1);
    int         nReadSoFar = 0;

/* -------------------------------------------------------------------- */
/*      Cleanup case.                                                   */
/* -------------------------------------------------------------------- */
    if( fp == NULL )
    {
        CPLReadLineBuffer( -1 );
        return NULL;
    }

/* -------------------------------------------------------------------- */
/*      Loop reading chunks of the line till we get to the end of       */
/*      the line.                                                       */
/* -------------------------------------------------------------------- */
    int nBytesReadThisTime;

    do {
/* -------------------------------------------------------------------- */
/*      Grow the working buffer if we have it nearly full.  Fail out    */
/*      of read line if we can't reallocate it big enough (for          */
/*      instance for a _very large_ file with no newlines).             */
/* -------------------------------------------------------------------- */
        pszRLBuffer = CPLReadLineBuffer( nReadSoFar + 129 );
        if( pszRLBuffer == NULL )
            return NULL;

/* -------------------------------------------------------------------- */
/*      Do the actual read.                                             */
/* -------------------------------------------------------------------- */
        if( CPLFGets( pszRLBuffer+nReadSoFar, 128, fp ) == NULL )
            return NULL;

        nBytesReadThisTime = strlen(pszRLBuffer+nReadSoFar);
        nReadSoFar += nBytesReadThisTime;

    } while( nBytesReadThisTime >= 127
             && pszRLBuffer[nReadSoFar-1] != 13
             && pszRLBuffer[nReadSoFar-1] != 10 );

    return( pszRLBuffer );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
callq 0x30d3
testq %rbx, %rbx
je 0x30b7
xorl %r12d, %r12d
leal 0x81(%r12), %edi
callq 0x30d3
testq %rax, %rax
je 0x30c1
movq %rax, %r14
movslq %r12d, %r15
addq %rax, %r15
movq %r15, %rdi
movl $0x80, %esi
movq %rbx, %rdx
callq 0x2ebc
testq %rax, %rax
je 0x30c1
movq %r15, %rdi
callq 0x2120
cmpl $0x7f, %eax
jl 0x30c4
movl %r12d, %ecx
movl %eax, %r12d
addq %rcx, %r12
movzbl -0x1(%r14,%r12), %eax
cmpl $0xd, %eax
je 0x30c4
cmpl $0xa, %eax
jne 0x305f
jmp 0x30c4
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x30d3
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLReadLineBuffer(int)
static char *CPLReadLineBuffer( int nRequiredSize )

{
    
/* -------------------------------------------------------------------- */
/*      A required size of -1 means the buffer should be freed.         */
/* -------------------------------------------------------------------- */
    if( nRequiredSize == -1 )
    {
        if( CPLGetTLS( CTLS_RLBUFFERINFO ) != NULL )
        {
            CPLFree( CPLGetTLS( CTLS_RLBUFFERINFO ) );
            CPLSetTLS( CTLS_RLBUFFERINFO, NULL, FALSE );
        }
        return NULL;
    }

/* -------------------------------------------------------------------- */
/*      If the buffer doesn't exist yet, create it.                     */
/* -------------------------------------------------------------------- */
    GUInt32 *pnAlloc = (GUInt32 *) CPLGetTLS( CTLS_RLBUFFERINFO );

    if( pnAlloc == NULL )
    {
        pnAlloc = (GUInt32 *) CPLMalloc(200);
        *pnAlloc = 196;
        CPLSetTLS( CTLS_RLBUFFERINFO, pnAlloc, TRUE );
    }

/* -------------------------------------------------------------------- */
/*      If it is too small, grow it bigger.                             */
/* -------------------------------------------------------------------- */
    if( (int) *pnAlloc < nRequiredSize+1 )
    {
        int nNewSize = nRequiredSize + 4 + 500;

        pnAlloc = (GUInt32 *) CPLRealloc(pnAlloc,nNewSize);
        if( pnAlloc == NULL )
        {
            CPLSetTLS( CTLS_RLBUFFERINFO, NULL, FALSE );
            return NULL;
        }
            
        *pnAlloc = nNewSize - 4;
        CPLSetTLS( CTLS_RLBUFFERINFO, pnAlloc, TRUE );
    }

    return (char *) (pnAlloc+1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %r14d
movl $0x1, %edi
callq 0x5177
movq %rax, %rbx
cmpl $-0x1, %r14d
je 0x314f
testq %rbx, %rbx
jne 0x3117
movl $0xc8, %edi
callq 0x2d9b
movq %rax, %rbx
movl $0xc4, (%rax)
movl $0x1, %edi
movq %rax, %rsi
movl $0x1, %edx
callq 0x51aa
cmpl %r14d, (%rbx)
jg 0x318b
leal 0x1f8(%r14), %eax
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x2df9
movq %rax, %rbx
testq %rax, %rax
je 0x3178
addl $0x1f4, %r14d           # imm = 0x1F4
movl %r14d, (%rbx)
movl $0x1, %edi
movq %rbx, %rsi
movl $0x1, %edx
jmp 0x3181
testq %rbx, %rbx
je 0x3191
movl $0x1, %edi
callq 0x5177
movq %rax, %rdi
callq 0x701d
xorl %ebx, %ebx
movl $0x1, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x51aa
jmp 0x3193
movl $0x1, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x51aa
testq %rbx, %rbx
je 0x3191
addq $0x4, %rbx
jmp 0x3193
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLScanString
char *CPLScanString( const char *pszString, int nMaxLength,
                     int bTrimSpaces, int bNormalize )
{
    char    *pszBuffer;

    if ( !pszString )
        return NULL;

    if ( !nMaxLength )
        return CPLStrdup( "" );

    pszBuffer = (char *)CPLMalloc( nMaxLength + 1 );
    if ( !pszBuffer )
        return NULL;

    strncpy( pszBuffer, pszString,  nMaxLength );
    pszBuffer[nMaxLength] = '\0';

    if ( bTrimSpaces )
    {
        size_t  i = strlen( pszBuffer );
        while ( i-- > 0 && isspace(pszBuffer[i]) )
            pszBuffer[i] = '\0';
    }

    if ( bNormalize )
    {
        size_t  i = strlen( pszBuffer );
        while ( i-- > 0 )
        {
            if ( pszBuffer[i] == ':' )
                pszBuffer[i] = '_';
        }
    }

    return pszBuffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x33da
movl %esi, %r12d
testl %esi, %esi
je 0x33e8
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %r15
leal 0x1(%r12), %eax
movslq %eax, %rdi
callq 0x2d9b
testq %rax, %rax
je 0x33da
movq %rax, %rbx
movslq %r12d, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2160
movb $0x0, (%rbx,%r12)
testl %r14d, %r14d
je 0x33b6
movq %rbx, %rdi
callq 0x2120
testq %rax, %rax
je 0x33b6
movq %rax, %r14
movsbl -0x1(%rbx,%r14), %edi
callq 0x2060
testl %eax, %eax
je 0x33b6
movb $0x0, -0x1(%rbx,%r14)
decq %r14
jne 0x339c
testl %ebp, %ebp
je 0x33dc
movq %rbx, %rdi
callq 0x2120
testq %rax, %rax
je 0x33dc
cmpb $0x3a, -0x1(%rbx,%rax)
jne 0x33d3
movb $0x5f, -0x1(%rbx,%rax)
decq %rax
jne 0x33c7
jmp 0x33dc
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xdbc5(%rip), %rdi      # 0x10fb4
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2e6c
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLScanLong
long CPLScanLong( const char *pszString, int nMaxLength )
{
    long    iValue;
    char    *pszValue = (char *)CPLMalloc( nMaxLength + 1);

/* -------------------------------------------------------------------- */
/*      Compute string into local buffer, and terminate it.             */
/* -------------------------------------------------------------------- */
    strncpy( pszValue, pszString, nMaxLength );
    pszValue[nMaxLength] = '\0';

/* -------------------------------------------------------------------- */
/*      Use atol() to fetch out the result                              */
/* -------------------------------------------------------------------- */
    iValue = atol( pszValue );

    CPLFree( pszValue );
    return iValue;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leal 0x1(%rbx), %eax
movslq %eax, %rdi
callq 0x2d9b
movq %rax, %r15
movslq %ebx, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2160
movb $0x0, (%r15,%rbx)
movq %r15, %rdi
callq 0x2370
movq %rax, %rbx
movq %r15, %rdi
callq 0x701d
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLScanPointer
void *CPLScanPointer( const char *pszString, int nMaxLength )
{
    void  *pResult;
    char  szTemp[128];

/* -------------------------------------------------------------------- */
/*      Compute string into local buffer, and terminate it.             */
/* -------------------------------------------------------------------- */
    if( nMaxLength > (int) sizeof(szTemp)-1 )
        nMaxLength = sizeof(szTemp)-1;

    strncpy( szTemp, pszString, nMaxLength );
    szTemp[nMaxLength] = '\0';

/* -------------------------------------------------------------------- */
/*      On MSVC we have to scanf pointer values without the 0x          */
/*      prefix.                                                         */
/* -------------------------------------------------------------------- */
    if( EQUALN(szTemp,"0x",2) )
    {
        pResult = NULL;

#if defined(WIN32) && defined(_MSC_VER)
        sscanf( szTemp+2, "%p", &pResult );
#else
        sscanf( szTemp, "%p", &pResult );
#endif
    }
    
    else
    {
        pResult = (void *) CPLScanUIntBig( szTemp, nMaxLength );
    }

    return pResult;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rax
cmpl $0x7f, %esi
movl $0x7f, %ebx
cmovll %esi, %ebx
movslq %ebx, %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2160
movb $0x0, 0x10(%rsp,%r14)
leaq 0xdfeb(%rip), %rsi      # 0x114b8
movl $0x2, %edx
movq %r15, %rdi
callq 0x23c0
testl %eax, %eax
je 0x34f1
leaq 0x10(%rsp), %rdi
movl %ebx, %esi
callq 0x3446
movq %rax, 0x8(%rsp)
jmp 0x3510
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0xced3(%rip), %rsi      # 0x103d7
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x22d0
movq 0x8(%rsp), %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLPrintString
int CPLPrintString( char *pszDest, const char *pszSrc, int nMaxLen )
{
    char    *pszTemp = pszDest;
    int     nChars = 0;

    if ( !pszDest )
        return 0;

    if ( !pszSrc )
    {
        *pszDest = '\0';
        return 1;
    }

    while ( nChars < nMaxLen && *pszSrc )
    {
        *pszTemp++ = *pszSrc++;
        nChars++;
    }

    return nChars;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x35c2
testq %rsi, %rsi
je 0x35c3
testl %edx, %edx
jle 0x35c2
movl %edx, %eax
xorl %ecx, %ecx
movb (%rsi,%rcx), %dl
testb %dl, %dl
je 0x35cc
movb %dl, (%rdi,%rcx)
incq %rcx
cmpl %ecx, %eax
jne 0x35b1
retq
movb $0x0, (%rdi)
movl $0x1, %eax
retq
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLPrintStringFill
int CPLPrintStringFill( char *pszDest, const char *pszSrc, int nMaxLen )
{
    char    *pszTemp = pszDest;

    if ( !pszDest )
        return 0;

    if ( !pszSrc )
    {
        memset( pszDest, ' ', nMaxLen );
        return nMaxLen;
    }

    while ( nMaxLen && *pszSrc )
    {
        *pszTemp++ = *pszSrc++;
        nMaxLen--;
    }

    if ( nMaxLen )
        memset( pszTemp, ' ', nMaxLen );

    return nMaxLen;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x35fc
movl %edx, %ebx
testq %rsi, %rsi
je 0x3600
testl %ebx, %ebx
je 0x3625
movl %ebx, %eax
xorl %r14d, %r14d
movb (%rsi,%r14), %cl
testb %cl, %cl
je 0x360f
movb %cl, (%rdi,%r14)
incq %r14
cmpl %r14d, %eax
jne 0x35e8
xorl %ebx, %ebx
jmp 0x3625
movslq %ebx, %rdx
movl $0x20, %esi
callq 0x2170
jmp 0x3625
addq %r14, %rdi
movslq %ebx, %rdx
subq %r14, %rdx
movl $0x20, %esi
callq 0x2170
subl %r14d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLPrintInt32
int CPLPrintInt32( char *pszBuffer, GInt32 iValue, int nMaxLen )
{
    char    szTemp[64];

    if ( !pszBuffer )
        return 0;

    if ( nMaxLen >= 64 )
        nMaxLen = 63;

#if UINT_MAX == 65535
    sprintf( szTemp, "%*ld", nMaxLen, iValue );
#else
    sprintf( szTemp, "%*d", nMaxLen, iValue );
#endif

    return CPLPrintString( pszBuffer, szTemp, nMaxLen );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
testq %rdi, %rdi
je 0x3698
movl %edx, %r15d
movl %esi, %ecx
movq %rdi, %rbx
cmpl $0x3f, %edx
movl $0x3f, %ebp
cmovll %edx, %ebp
leaq 0xcd74(%rip), %rsi      # 0x103cc
xorl %r14d, %r14d
movq %rsp, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x20a0
testl %r15d, %r15d
jle 0x369b
movslq %r15d, %rcx
cmpq $0x3f, %rcx
movl $0x3f, %eax
cmovlq %rcx, %rax
xorl %r14d, %r14d
movb (%rsp,%r14), %cl
testb %cl, %cl
je 0x369b
movb %cl, (%rbx,%r14)
incq %r14
cmpl %r14d, %eax
jne 0x367f
movl %ebp, %r14d
jmp 0x369b
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLPrintUIntBig
int CPLPrintUIntBig( char *pszBuffer, GUIntBig iValue, int nMaxLen )
{
    char    szTemp[64];

    if ( !pszBuffer )
        return 0;

    if ( nMaxLen >= 64 )
        nMaxLen = 63;

#if defined(WIN32) && defined(_MSC_VER)
    sprintf( szTemp, "%*I64d", nMaxLen, iValue );
# elif HAVE_LONG_LONG
    sprintf( szTemp, "%*lld", nMaxLen, (long long) iValue );
//    sprintf( szTemp, "%*Ld", nMaxLen, (long long) iValue );
#else
    sprintf( szTemp, "%*ld", nMaxLen, iValue );
#endif

    return CPLPrintString( pszBuffer, szTemp, nMaxLen );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
testq %rdi, %rdi
je 0x3713
movl %edx, %r15d
movq %rsi, %rcx
movq %rdi, %rbx
cmpl $0x3f, %edx
movl $0x3f, %ebp
cmovll %edx, %ebp
leaq 0xccfd(%rip), %rsi      # 0x103d0
xorl %r14d, %r14d
movq %rsp, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x20a0
testl %r15d, %r15d
jle 0x3716
movslq %r15d, %rcx
cmpq $0x3f, %rcx
movl $0x3f, %eax
cmovlq %rcx, %rax
xorl %r14d, %r14d
movb (%rsp,%r14), %cl
testb %cl, %cl
je 0x3716
movb %cl, (%rbx,%r14)
incq %r14
cmpl %r14d, %eax
jne 0x36fa
movl %ebp, %r14d
jmp 0x3716
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLPrintPointer
int CPLPrintPointer( char *pszBuffer, void *pValue, int nMaxLen )
{
    char    szTemp[64];

    if ( !pszBuffer )
        return 0;

    if ( nMaxLen >= 64 )
        nMaxLen = 63;

    sprintf( szTemp, "%p", pValue );

    // On windows, and possibly some other platforms the sprintf("%p")
    // does not prefix things with 0x so it is hard to know later if the
    // value is hex encoded.  Fix this up here. 

    if( !EQUALN(szTemp,"0x",2) )
        sprintf( szTemp, "0x%p", pValue );

    return CPLPrintString( pszBuffer, szTemp, nMaxLen );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testq %rdi, %rdi
je 0x37c6
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x3f, %edx
movl $0x3f, %r13d
cmovll %edx, %r13d
leaq 0xcc80(%rip), %rsi      # 0x103d7
xorl %r14d, %r14d
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x20a0
leaq 0xdd47(%rip), %rsi      # 0x114b8
movl $0x2, %edx
movq %r12, %rdi
callq 0x23c0
testl %eax, %eax
je 0x3796
leaq 0xcc4c(%rip), %rsi      # 0x103d5
movq %rsp, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x20a0
testl %ebp, %ebp
jle 0x37c9
movslq %ebp, %rcx
cmpq $0x3f, %rcx
movl $0x3f, %eax
cmovlq %rcx, %rax
xorl %r14d, %r14d
movb (%rsp,%r14), %cl
testb %cl, %cl
je 0x37c9
movb %cl, (%rbx,%r14)
incq %r14
cmpl %r14d, %eax
jne 0x37ad
movl %r13d, %r14d
jmp 0x37c9
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLPrintTime
int CPLPrintTime( char *pszBuffer, int nMaxLen, const char *pszFormat,
                  const struct tm *poBrokenTime, char *pszLocale )
{
    char    *pszTemp = (char *)CPLMalloc( (nMaxLen + 1) * sizeof(char) );
    int     nChars;

#if defined(HAVE_LOCALE_H) && defined(HAVE_SETLOCALE)
    char        *pszCurLocale = NULL;

    if ( pszLocale || EQUAL( pszLocale, "" ) )
    {
        // Save the current locale
        pszCurLocale = setlocale(LC_ALL, NULL );
        // Set locale to the specified value
        setlocale( LC_ALL, pszLocale );
    }
#endif
    
    if ( !strftime( pszTemp, nMaxLen + 1, pszFormat, poBrokenTime ) )
        memset( pszTemp, 0, nMaxLen + 1);

#if defined(HAVE_LOCALE_H) && defined(HAVE_SETLOCALE)
    // Restore stored locale back
    if ( pszCurLocale )
        setlocale( LC_ALL, pszCurLocale );
#endif

    nChars = CPLPrintString( pszBuffer, pszTemp, nMaxLen );

    CPLFree( pszTemp );

    return nChars;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r13
movq %rdx, %rbp
movl %esi, %r12d
movq %rdi, %r14
leal 0x1(%r12), %eax
movslq %eax, %r15
movq %r15, %rdi
callq 0x2d9b
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r13, %rcx
callq 0x2230
testq %rax, %rax
jne 0x3892
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2170
xorl %r15d, %r15d
testq %r14, %r14
je 0x38cd
testq %rbx, %rbx
je 0x38be
testl %r12d, %r12d
jle 0x38cd
movl %r12d, %r15d
xorl %eax, %eax
movb (%rbx,%rax), %cl
testb %cl, %cl
je 0x38ca
movb %cl, (%r14,%rax)
incq %rax
cmpl %eax, %r15d
jne 0x38a9
jmp 0x38cd
movb $0x0, (%r14)
movl $0x1, %r15d
jmp 0x38cd
movl %eax, %r15d
movq %rbx, %rdi
callq 0x701d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLGetConfigOption
const char * CPL_STDCALL
CPLGetConfigOption( const char *pszKey, const char *pszDefault )

{
    const char *pszResult = NULL;

    {
        CPLMutexHolderD( &hConfigMutex );

        pszResult = CSLFetchNameValue( (char **) papszConfigOptions, pszKey );
    }

#if !defined(WIN32CE) 
    if( pszResult == NULL )
        pszResult = getenv( pszKey );
#endif
    
    if( pszResult == NULL )
        return pszDefault;
    else
        return pszResult;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x129fb(%rip), %rsi     # 0x162f8
leaq 0xcad6(%rip), %rdx      # 0x103da
leaq 0x8(%rsp), %rdi
movsd 0xc907(%rip), %xmm0     # 0x10218
movl $0x5b3, %ecx            # imm = 0x5B3
callq 0x4f80
movq 0x129de(%rip), %rdi     # 0x16300
movq %r14, %rsi
callq 0x65ec
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x4f82
testq %r15, %r15
jne 0x3947
movq %r14, %rdi
callq 0x2390
movq %rax, %r15
testq %r15, %r15
cmovneq %r15, %rbx
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4f82
movq %rbx, %rdi
callq 0x2510
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLStat
int CPLStat( const char *pszPath, VSIStatBuf *psStatBuf )

{
    if( strlen(pszPath) == 2 && pszPath[1] == ':' )
    {
        char    szAltPath[10];
        
        strncpy( szAltPath, pszPath, 10 );
        strcat( szAltPath, "\\" );
        return VSIStat( szAltPath, psStatBuf );
    }
    else
        return VSIStat( pszPath, psStatBuf );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2120
cmpq $0x2, %rax
jne 0x3a9c
cmpb $0x3a, 0x1(%r14)
jne 0x3a9c
leaq 0x6(%rsp), %r15
movl $0xa, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2160
movq %r15, %rdi
callq 0x2120
movw $0x5c, 0x6(%rsp,%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x702c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x702c
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLDecToDMS
const char *CPLDecToDMS( double dfAngle, const char * pszAxis,
                         int nPrecision )

{
    int         nDegrees, nMinutes;
    double      dfSeconds, dfABSAngle, dfEpsilon;
    char        szFormat[30];
    static CPL_THREADLOCAL char szBuffer[50];
    const char  *pszHemisphere;
    
    dfEpsilon = (0.5/3600.0) * pow(0.1,nPrecision);

    dfABSAngle = ABS(dfAngle) + dfEpsilon;

    nDegrees = (int) dfABSAngle;
    nMinutes = (int) ((dfABSAngle - nDegrees) * 60);
    dfSeconds = dfABSAngle * 3600 - nDegrees*3600 - nMinutes*60;

    if( dfSeconds > dfEpsilon * 3600.0 )
        dfSeconds -= dfEpsilon * 3600.0;

    if( EQUAL(pszAxis,"Long") && dfAngle < 0.0 )
        pszHemisphere = "W";
    else if( EQUAL(pszAxis,"Long") )
        pszHemisphere = "E";
    else if( dfAngle < 0.0 )
        pszHemisphere = "S";
    else
        pszHemisphere = "N";

    sprintf( szFormat, "%%3dd%%2d\'%%.%df\"%s", nPrecision, pszHemisphere );
    sprintf( szBuffer, szFormat, nDegrees, nMinutes, dfSeconds );

    return( szBuffer );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebx
movq %rdi, %r15
movaps %xmm0, 0x10(%rsp)
cvtsi2sd %esi, %xmm1
movsd 0xc534(%rip), %xmm0     # 0x10228
callq 0x2500
mulsd 0xc52f(%rip), %xmm0     # 0x10230
movapd %xmm0, (%rsp)
movapd 0xc552(%rip), %xmm2     # 0x10260
movapd 0x10(%rsp), %xmm1
xorpd %xmm1, %xmm2
movapd %xmm2, 0x30(%rsp)
maxsd %xmm1, %xmm2
addsd %xmm0, %xmm2
movapd %xmm2, 0x20(%rsp)
cvttsd2si %xmm2, %ebp
cvttpd2dq %xmm2, %xmm0
cvtdq2pd %xmm0, %xmm0
movapd %xmm2, %xmm1
subsd %xmm0, %xmm1
mulsd 0xc4f0(%rip), %xmm1     # 0x10238
cvttsd2si %xmm1, %r14d
imull $0xe10, %ebp, %r12d     # imm = 0xE10
imull $0x3c, %r14d, %r13d
leaq 0xc688(%rip), %rsi      # 0x103e7
movq %r15, %rdi
callq 0x22f0
movapd 0x30(%rsp), %xmm0
ucomisd 0x10(%rsp), %xmm0
xorps %xmm0, %xmm0
cvtsi2sd %r12d, %xmm0
movsd 0xc4bd(%rip), %xmm1     # 0x10240
movapd 0x20(%rsp), %xmm3
mulsd %xmm1, %xmm3
subsd %xmm0, %xmm3
xorps %xmm0, %xmm0
cvtsi2sd %r13d, %xmm0
subsd %xmm0, %xmm3
movapd (%rsp), %xmm2
mulsd %xmm1, %xmm2
movapd %xmm3, %xmm0
subsd %xmm2, %xmm0
cmpltsd %xmm3, %xmm2
andpd %xmm2, %xmm0
andnpd %xmm3, %xmm2
leaq 0xcf1b(%rip), %rcx      # 0x10cdd
leaq 0xcf08(%rip), %rdx      # 0x10cd1
cmovaq %rcx, %rdx
leaq 0xcf18(%rip), %rsi      # 0x10cec
leaq 0xcee1(%rip), %rcx      # 0x10cbc
cmovaq %rsi, %rcx
orpd %xmm0, %xmm2
movapd %xmm2, (%rsp)
testl %eax, %eax
cmovneq %rdx, %rcx
leaq 0xc5f7(%rip), %rsi      # 0x103ec
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x20a0
leaq 0x12503(%rip), %rbx     # 0x16310
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %r14d, %ecx
movaps (%rsp), %xmm0
movb $0x1, %al
callq 0x20a0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLPackedDMSToDec
double CPLPackedDMSToDec( double dfPacked )
{
    double  dfDegrees, dfMinutes, dfSeconds, dfSign;

    dfSign = ( dfPacked < 0.0 )? -1 : 1;
        
    dfSeconds = ABS( dfPacked );
    dfDegrees = floor(dfSeconds / 1000000.0);
    dfSeconds = dfSeconds - dfDegrees * 1000000.0;
    dfMinutes = floor(dfSeconds / 1000.0);
    dfSeconds = dfSeconds - dfMinutes * 1000.0;
    dfSeconds = dfSign * ( dfDegrees * 3600.0 + dfMinutes * 60.0 + dfSeconds);
    dfDegrees = dfSeconds / 3600.0;

    return dfDegrees;
}

// Assembly:
subq $0x48, %rsp
movapd %xmm0, 0x20(%rsp)
movapd %xmm0, %xmm2
xorpd 0xc415(%rip), %xmm2     # 0x10260
movapd %xmm2, 0x30(%rsp)
maxsd %xmm0, %xmm2
movapd %xmm2, (%rsp)
movapd %xmm2, %xmm0
divsd 0xc3e2(%rip), %xmm0     # 0x10248
callq 0x24f0
movapd %xmm0, 0x10(%rsp)
movsd 0xc3cf(%rip), %xmm2     # 0x10248
mulsd %xmm0, %xmm2
movapd (%rsp), %xmm0
subsd %xmm2, %xmm0
movapd %xmm0, (%rsp)
divsd 0xc385(%rip), %xmm0     # 0x10218
callq 0x24f0
movsd 0xc378(%rip), %xmm1     # 0x10218
mulsd %xmm0, %xmm1
movapd (%rsp), %xmm3
subsd %xmm1, %xmm3
mulsd 0xc383(%rip), %xmm0     # 0x10238
movsd 0xc383(%rip), %xmm1     # 0x10240
movapd 0x10(%rsp), %xmm2
mulsd %xmm1, %xmm2
addsd %xmm0, %xmm2
addsd %xmm3, %xmm2
movapd 0xc389(%rip), %xmm3     # 0x10260
xorpd %xmm2, %xmm3
movapd %xmm2, %xmm4
movapd 0x20(%rsp), %xmm0
cmpltsd 0x30(%rsp), %xmm0
movapd %xmm0, %xmm2
andnpd %xmm4, %xmm2
andpd %xmm3, %xmm0
orpd %xmm2, %xmm0
divsd %xmm1, %xmm0
addq $0x48, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLDecToPackedDMS
double CPLDecToPackedDMS( double dfDec )
{
    double  dfDegrees, dfMinutes, dfSeconds, dfSign;

    dfSign = ( dfDec < 0.0 )? -1 : 1;

    dfDec = ABS( dfDec );
    dfDegrees = floor( dfDec );
    dfMinutes = floor( ( dfDec - dfDegrees ) * 60.0 );
    dfSeconds = ( dfDec - dfDegrees ) * 3600.0 - dfMinutes * 60.0;

    return dfSign * (dfDegrees * 1000000.0 + dfMinutes * 1000.0 + dfSeconds);
}

// Assembly:
subq $0x48, %rsp
movapd %xmm0, 0x20(%rsp)
movapd %xmm0, %xmm2
xorpd 0xc345(%rip), %xmm2     # 0x10260
movapd %xmm2, 0x30(%rsp)
maxsd %xmm0, %xmm2
movapd %xmm2, (%rsp)
movapd %xmm2, %xmm0
callq 0x24f0
movapd %xmm0, 0x10(%rsp)
movapd (%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
movsd 0xc2e9(%rip), %xmm0     # 0x10238
mulsd %xmm1, %xmm0
callq 0x24f0
movsd 0xc2f0(%rip), %xmm1     # 0x10250
mulsd %xmm0, %xmm1
movapd (%rsp), %xmm2
mulsd 0xc2cf(%rip), %xmm2     # 0x10240
mulsd 0xc29f(%rip), %xmm0     # 0x10218
addsd %xmm1, %xmm2
movapd 0x10(%rsp), %xmm1
mulsd 0xc2bd(%rip), %xmm1     # 0x10248
addsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movapd 0xc2c5(%rip), %xmm2     # 0x10260
xorpd %xmm1, %xmm2
movapd %xmm1, %xmm3
movapd 0x20(%rsp), %xmm1
cmpltsd 0x30(%rsp), %xmm1
movapd %xmm1, %xmm0
andnpd %xmm3, %xmm0
andpd %xmm2, %xmm1
orpd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x48, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLStringToComplex
void CPL_DLL CPLStringToComplex( const char *pszString, 
                                 double *pdfReal, double *pdfImag )

{
    int  i;
    int  iPlus = -1, iImagEnd = -1;

    while( *pszString == ' ' )
        pszString++;

    *pdfReal = atof(pszString);
    *pdfImag = 0.0;

    for( i = 0; pszString[i] != '\0' && pszString[i] != ' ' && i < 100; i++ )
    {
        if( pszString[i] == '+' && i > 0 )
            iPlus = i;
        if( pszString[i] == '-' && i > 0 )
            iPlus = i;
        if( pszString[i] == 'i' )
            iImagEnd = i;
    }

    if( iPlus > -1 && iImagEnd > -1 && iPlus < iImagEnd )
    {
        *pdfImag = atof(pszString + iPlus);
    }

    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
decq %r14
cmpb $0x20, 0x1(%r14)
leaq 0x1(%r14), %r14
je 0x3fda
movq %r14, %rdi
callq 0x23a0
movsd %xmm0, (%r15)
movq $0x0, (%rbx)
movb (%r14), %dl
testb %dl, %dl
je 0x403d
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %esi, %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x63, %rsi
ja 0x4047
cmpb $0x20, %dl
je 0x4047
leal -0x2b(%rdx), %edi
testb $-0x3, %dil
movl %eax, %edi
cmovel %esi, %edi
testq %rsi, %rsi
cmovnel %edi, %eax
cmpb $0x69, %dl
cmovel %esi, %ecx
movb 0x1(%r14,%rsi), %dl
incq %rsi
testb %dl, %dl
jne 0x400c
jmp 0x4047
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x4064
testl %ecx, %ecx
js 0x4064
cmpl %ecx, %eax
jge 0x4064
movl %eax, %eax
addq %rax, %r14
movq %r14, %rdi
callq 0x23a0
movsd %xmm0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLDumpSharedList
void CPLDumpSharedList( FILE *fp )

{
    int i;

    if( nSharedFileCount > 0 )
    {
        if( fp == NULL )
            CPLDebug( "CPL", "%d Shared files open.", nSharedFileCount );
        else
            fprintf( fp, "%d Shared files open.", nSharedFileCount );
    }

    for( i = 0; i < nSharedFileCount; i++ )
    {
        if( fp == NULL )
            CPLDebug( "CPL", 
                      "%2d %d %4s %s", 
                      pasSharedFileList[i].nRefCount, 
                      pasSharedFileList[i].bLarge,
                      pasSharedFileList[i].pszAccess,
                      pasSharedFileList[i].pszFilename );
        else
            fprintf( fp, "%2d %d %4s %s", 
                     pasSharedFileList[i].nRefCount, 
                     pasSharedFileList[i].bLarge,
                     pasSharedFileList[i].pszAccess,
                     pasSharedFileList[i].pszFilename );
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x11fb1(%rip)     # 0x16350
jle 0x43d4
movl 0x11fa9(%rip), %edx     # 0x16350
testq %rbx, %rbx
je 0x43bf
leaq 0xc087(%rip), %rsi      # 0x1043a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2420
jmp 0x43d4
leaq 0xbfc0(%rip), %rdi      # 0x10386
leaq 0xc06d(%rip), %rsi      # 0x1043a
xorl %eax, %eax
callq 0x48d9
cmpl $0x0, 0x11f75(%rip)     # 0x16350
jle 0x4442
movl $0x18, %r12d
leaq 0xbf9c(%rip), %r14      # 0x10386
leaq 0xc05f(%rip), %r15      # 0x10450
xorl %r13d, %r13d
movq 0x11f5d(%rip), %rax     # 0x16358
movl -0x10(%rax,%r12), %edx
movl -0xc(%rax,%r12), %ecx
movq (%rax,%r12), %r8
movq -0x8(%rax,%r12), %r9
testq %rbx, %rbx
je 0x4422
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2420
jmp 0x442f
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x48d9
incq %r13
movslq 0x11f17(%rip), %rax     # 0x16350
addq $0x20, %r12
cmpq %rax, %r13
jl 0x43f4
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_dir.cpp
// Function: CPLReadDir
char **CPLReadDir(const char *pszPath)
{
    DIR           *hDir;
    struct dirent *psDirEntry;
    char          **papszDir = NULL;

    if (strlen(pszPath) == 0)
        pszPath = ".";

    if ( (hDir = opendir(pszPath)) != NULL )
    {
        while( (psDirEntry = readdir(hDir)) != NULL )
        {
            papszDir = CSLAddString(papszDir, psDirEntry->d_name);
        }

        closedir( hDir );
    }
    else
    {
        /* Should we generate an error???  
         * For now we'll just return NULL (at the end of the function)
         */
    }

    return papszDir;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, (%rdi)
leaq 0xd6ea(%rip), %rax      # 0x11d70
cmoveq %rax, %rdi
callq 0x2450
testq %rax, %rax
je 0x46cd
movq %rax, %rbx
movq %rax, %rdi
callq 0x2460
xorl %r14d, %r14d
testq %rax, %rax
je 0x46c3
addq $0x13, %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x58a4
movq %rax, %r14
movq %rbx, %rdi
callq 0x2460
jmp 0x46a2
movq %rbx, %rdi
callq 0x24d0
jmp 0x46d0
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_error.cpp
// Function: CPLGetErrorContext()
static CPLErrorContext *CPLGetErrorContext()

{
    CPLErrorContext *psCtx = 
        (CPLErrorContext *) CPLGetTLS( CTLS_ERRORCONTEXT );

    if( psCtx == NULL )
    {
        psCtx = (CPLErrorContext *) CPLCalloc(sizeof(CPLErrorContext),1);
        psCtx->eLastErrType = CE_None;
        psCtx->nLastErrMsgMax = sizeof(psCtx->szLastErrMsg);
        CPLSetTLS( CTLS_ERRORCONTEXT, psCtx, TRUE );
    }

    return psCtx;
}

// Assembly:
pushq %rbx
movl $0x5, %edi
callq 0x5177
movq %rax, %rbx
testq %rax, %rax
jne 0x48d4
movl $0x208, %edi            # imm = 0x208
movl $0x1, %esi
callq 0x2d54
movq %rax, %rbx
movl $0x0, 0x4(%rax)
movl $0x1f4, 0x10(%rax)      # imm = 0x1F4
movl $0x5, %edi
movq %rax, %rsi
movl $0x1, %edx
callq 0x51aa
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_error.cpp
// Function: CPLDefaultErrorHandler
void CPL_STDCALL CPLDefaultErrorHandler( CPLErr eErrClass, int nError, 
                             const char * pszErrorMsg )

{
    static int       bLogInit = FALSE;
    static FILE *    fpLog = stderr;

    if( !bLogInit )
    {
        bLogInit = TRUE;

        fpLog = stderr;
        if( CPLGetConfigOption( "CPL_LOG", NULL ) != NULL )
        {
            fpLog = fopen( CPLGetConfigOption("CPL_LOG",""), "wt" );
            if( fpLog == NULL )
                fpLog = stderr;
        }
    }

    if( eErrClass == CE_Debug )
        fprintf( fpLog, "%s\n", pszErrorMsg );
    else if( eErrClass == CE_Warning )
        fprintf( fpLog, "Warning %d: %s\n", nError, pszErrorMsg );
    else
        fprintf( fpLog, "ERROR %d: %s\n", nError, pszErrorMsg );

    fflush( fpLog );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movl %edi, %r14d
movb 0x117df(%rip), %al      # 0x16378
testb %al, %al
je 0x4c65
cmpb $0x0, 0x117c0(%rip)     # 0x16368
jne 0x4c0d
movb $0x1, 0x117b7(%rip)     # 0x16368
movq 0x11428(%rip), %r15     # 0x15fe0
movq (%r15), %rax
movq %rax, 0x117ae(%rip)     # 0x16370
leaq 0xb980(%rip), %rdi      # 0x10549
xorl %esi, %esi
callq 0x38e7
testq %rax, %rax
je 0x4c0d
leaq 0xb96d(%rip), %rdi      # 0x10549
leaq 0xc3d1(%rip), %rsi      # 0x10fb4
callq 0x38e7
leaq 0xb962(%rip), %rsi      # 0x10551
movq %rax, %rdi
callq 0x2350
movq %rax, 0x11772(%rip)     # 0x16370
testq %rax, %rax
jne 0x4c0d
movq (%r15), %rax
movq %rax, 0x11763(%rip)     # 0x16370
movq 0x1175c(%rip), %rdi     # 0x16370
cmpl $0x2, %r14d
je 0x4c33
cmpl $0x1, %r14d
jne 0x4c3c
leaq 0xb947(%rip), %rsi      # 0x1056e
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2420
jmp 0x4c4f
leaq 0xb91a(%rip), %rsi      # 0x10554
jmp 0x4c43
leaq 0xb921(%rip), %rsi      # 0x10564
movl %ebp, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2420
movq 0x1171a(%rip), %rdi     # 0x16370
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2340
callq 0x2590
jmp 0x4ba1
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_error.cpp
// Function: CPLSetErrorHandler
CPLErrorHandler CPL_STDCALL 
CPLSetErrorHandler( CPLErrorHandler pfnErrorHandlerNew )
{
    CPLErrorHandler     pfnOldHandler = pfnErrorHandler;
    CPLErrorContext *psCtx = CPLGetErrorContext();

    if( psCtx->psHandlerStack != NULL )
    {
        CPLDebug( "CPL", 
                  "CPLSetErrorHandler() called with an error handler on\n"
                  "the local stack.  New error handler will not be used immediately.\n" );
    }


    {
        CPLMutexHolderD( &hErrorMutex );

        pfnOldHandler = pfnErrorHandler;
        
        if( pfnErrorHandler == NULL )
            pfnErrorHandler = CPLDefaultErrorHandler;
        else
            pfnErrorHandler = pfnErrorHandlerNew;
    }

    return pfnOldHandler;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x488f
cmpq $0x0, 0x8(%rax)
je 0x4eb8
leaq 0xb4dc(%rip), %rdi      # 0x10386
leaq 0xb6d2(%rip), %rsi      # 0x10583
xorl %eax, %eax
callq 0x48d9
leaq 0x114a1(%rip), %rsi     # 0x16360
leaq 0xb65a(%rip), %rdx      # 0x10520
leaq 0x8(%rsp), %r14
movsd 0xb345(%rip), %xmm0     # 0x10218
movq %r14, %rdi
movl $0x26b, %ecx            # imm = 0x26B
callq 0x4f80
movq 0x113f1(%rip), %r15     # 0x162d8
testq %r15, %r15
leaq -0x36d(%rip), %rax      # 0x4b84
cmoveq %rax, %rbx
movq %rbx, 0x113dc(%rip)     # 0x162d8
movq %r14, %rdi
callq 0x4f82
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_error.cpp
// Function: CPLPushErrorHandler
void CPL_STDCALL CPLPushErrorHandler( CPLErrorHandler pfnErrorHandlerNew )

{
    CPLErrorContext *psCtx = CPLGetErrorContext();
    CPLErrorHandlerNode         *psNode;

    psNode = (CPLErrorHandlerNode *) VSIMalloc(sizeof(CPLErrorHandlerNode));
    psNode->psNext = psCtx->psHandlerStack;
    psNode->pfnHandler = pfnErrorHandlerNew;

    psCtx->psHandlerStack = psNode;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x488f
movq %rax, %r14
movl $0x10, %edi
callq 0x7013
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
movq %rax, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_multiproc.cpp
// Function: CPLLockFile
void *CPLLockFile( const char *pszPath, double dfWaitInSeconds )

{
    FILE      *fpLock;
    char      *pszLockFilename;
    
/* -------------------------------------------------------------------- */
/*      We use a lock file with a name derived from the file we want    */
/*      to lock to represent the file being locked.  Note that for      */
/*      the stub implementation the target file does not even need      */
/*      to exist to be locked.                                          */
/* -------------------------------------------------------------------- */
    pszLockFilename = (char *) CPLMalloc(strlen(pszPath) + 30);
    sprintf( pszLockFilename, "%s.lock", pszPath );

    fpLock = fopen( pszLockFilename, "r" );
    while( fpLock != NULL && dfWaitInSeconds > 0.0 )
    {
        fclose( fpLock );
        CPLSleep( MIN(dfWaitInSeconds,0.5) );
        dfWaitInSeconds -= 0.5;

        fpLock = fopen( pszLockFilename, "r" );
    }
        
    if( fpLock != NULL )
    {
        fclose( fpLock );
        CPLFree( pszLockFilename );
        return NULL;
    }

    fpLock = fopen( pszLockFilename, "w" );

    if( fpLock == NULL )
    {
        CPLFree( pszLockFilename );
        return NULL;
    }

    fwrite( "held\n", 1, 5, fpLock );
    fclose( fpLock );

    return pszLockFilename;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rdi, %r14
callq 0x2120
leaq 0x1e(%rax), %rdi
callq 0x2d9b
movq %rax, %rbx
leaq 0xb682(%rip), %rsi      # 0x10645
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x20a0
leaq 0xb034(%rip), %rsi      # 0x1000b
movq %rbx, %rdi
callq 0x2350
testq %rax, %rax
setne %cl
je 0x5054
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x5054
movapd %xmm1, %xmm0
leaq 0xb00a(%rip), %r14      # 0x1000b
movsd %xmm0, (%rsp)
movq %rax, %rdi
callq 0x22e0
movsd (%rsp), %xmm0
minsd 0xb60d(%rip), %xmm0     # 0x10628
callq 0x50b1
movsd (%rsp), %xmm0
addsd 0xb603(%rip), %xmm0     # 0x10630
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2350
testq %rax, %rax
setne %cl
je 0x5054
movsd (%rsp), %xmm0
ucomisd 0xb5e6(%rip), %xmm0     # 0x10638
ja 0x5001
testb %cl, %cl
je 0x5062
movq %rax, %rdi
callq 0x22e0
jmp 0x509c
leaq 0xb481(%rip), %rsi      # 0x104ea
movq %rbx, %rdi
callq 0x2350
testq %rax, %rax
je 0x509c
movq %rax, %r14
leaq 0xb5cd(%rip), %rdi      # 0x1064d
movl $0x1, %esi
movl $0x5, %edx
movq %rax, %rcx
callq 0x2570
movq %r14, %rdi
callq 0x22e0
jmp 0x50a6
movq %rbx, %rdi
callq 0x701d
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_multiproc.cpp
// Function: CPLSleep
void CPLSleep( double dfWaitInSeconds )

{
    time_t  ltime;
    time_t  ttime;

    time( &ltime );
    ttime = ltime + (int) (dfWaitInSeconds+0.5);

    for( ; ltime < ttime; time(&ltime) )
    {
        /* currently we just busy wait.  Perhaps we could at least block on 
           io? */
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x2290
movsd 0x10(%rsp), %xmm0
addsd 0xb552(%rip), %xmm0     # 0x10628
cvttsd2si %xmm0, %eax
testl %eax, %eax
jle 0x50f8
movslq %eax, %r14
leaq 0x8(%rsp), %rbx
addq (%rbx), %r14
movq %rbx, %rdi
callq 0x2290
cmpq %r14, 0x8(%rsp)
jl 0x50e9
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_multiproc.cpp
// Function: CPLSetTLS
void CPLSetTLS( int nIndex, void *pData, int bFreeOnExit )

{
    void **papTLSList = CPLGetTLSList();

    CPLAssert( nIndex >= 0 && nIndex < CTLS_MAX );

    papTLSList[nIndex] = pData;
    papTLSList[CTLS_MAX + nIndex] = (void *) bFreeOnExit;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %ebp
cmpq $0x0, 0x111db(%rip)     # 0x16398
jne 0x51d5
movl $0x8, %edi
movl $0x40, %esi
callq 0x2d54
movq %rax, 0x111c3(%rip)     # 0x16398
movq 0x111bc(%rip), %rax     # 0x16398
movslq %ebp, %rcx
movq %r14, (%rax,%rcx,8)
movslq %ebx, %rdx
movq %rdx, 0x100(%rax,%rcx,8)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_path.cpp
// Function: CPLGetPath
const char *CPLGetPath( const char *pszFilename )

{
    int         iFileStart = CPLFindFilenameStart(pszFilename);
    char       *pszStaticResult = CPLGetStaticResult();

    CPLAssert( iFileStart < CPL_PATH_BUF_SIZE );

    if( iFileStart == 0 )
    {
        strcpy( pszStaticResult, "" );
        return pszStaticResult;
    }

    strncpy( pszStaticResult, pszFilename, iFileStart );
    pszStaticResult[iFileStart] = '\0';

    if( iFileStart > 1
        && (pszStaticResult[iFileStart-1] == '/'
            || pszStaticResult[iFileStart-1] == '\\') )
        pszStaticResult[iFileStart-1] = '\0';

    return pszStaticResult;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x5255
movl %eax, %ebp
callq 0x5287
movq %rax, %rbx
testl %ebp, %ebp
je 0x5244
movslq %ebp, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2160
movb $0x0, (%rbx,%r15)
cmpl $0x2, %ebp
jl 0x5247
movl %ebp, %ecx
leaq (%rbx,%rcx), %rax
decq %rax
movzbl -0x1(%rbx,%rcx), %ecx
cmpl $0x5c, %ecx
je 0x5244
cmpl $0x2f, %ecx
jne 0x5247
movb $0x0, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_path.cpp
// Function: CPLFindFilenameStart(char const*)
static int CPLFindFilenameStart( const char * pszFilename )

{
    int         iFileStart;

    for( iFileStart = strlen(pszFilename);
         iFileStart > 0
             && pszFilename[iFileStart-1] != '/'
             && pszFilename[iFileStart-1] != '\\';
         iFileStart-- ) {}

    return iFileStart;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2120
testl %eax, %eax
jle 0x5285
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movzbl -0x1(%rbx,%rax), %ecx
cmpl $0x2f, %ecx
je 0x5285
cmpl $0x5c, %ecx
je 0x5285
leaq -0x1(%rax), %rcx
cmpq $0x1, %rax
movq %rcx, %rax
jg 0x5267
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_path.cpp
// Function: CPLGetStaticResult()
static char *CPLGetStaticResult()

{
    char *pszStaticResult = (char *) CPLGetTLS( CTLS_PATHBUF );
    if( pszStaticResult == NULL )
    {
        pszStaticResult = (char *) CPLMalloc(CPL_PATH_BUF_SIZE);
        CPLSetTLS( CTLS_PATHBUF, pszStaticResult, TRUE );
    }

    return pszStaticResult;
}

// Assembly:
pushq %rbx
movl $0x7, %edi
callq 0x5177
movq %rax, %rbx
testq %rax, %rax
jne 0x52b9
movl $0x800, %edi            # imm = 0x800
callq 0x2d9b
movq %rax, %rbx
movl $0x7, %edi
movq %rax, %rsi
movl $0x1, %edx
callq 0x51aa
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_path.cpp
// Function: CPLGetFilename
const char *CPLGetFilename( const char *pszFullFilename )

{
    int iFileStart = CPLFindFilenameStart( pszFullFilename );
    char       *pszStaticResult = CPLGetStaticResult();

    strncpy( pszStaticResult, pszFullFilename + iFileStart, 
             CPL_PATH_BUF_SIZE );
    pszStaticResult[CPL_PATH_BUF_SIZE - 1] = '\0';

    return pszStaticResult;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x5255
movl %eax, %ebp
callq 0x5287
movq %rax, %r14
movslq %ebp, %rsi
addq %rbx, %rsi
movl $0x800, %edx            # imm = 0x800
movq %rax, %rdi
callq 0x2160
movb $0x0, 0x7ff(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_path.cpp
// Function: CPLGetBasename
const char *CPLGetBasename( const char *pszFullFilename )

{
    int iFileStart = CPLFindFilenameStart( pszFullFilename );
    int iExtStart, nLength;
    char *pszStaticResult = CPLGetStaticResult();

    for( iExtStart = strlen(pszFullFilename);
         iExtStart > iFileStart && pszFullFilename[iExtStart] != '.';
         iExtStart-- ) {}

    if( iExtStart == iFileStart )
        iExtStart = strlen(pszFullFilename);

    nLength = iExtStart - iFileStart;

    CPLAssert( nLength < CPL_PATH_BUF_SIZE );

    strncpy( pszStaticResult, pszFullFilename + iFileStart, nLength );
    pszStaticResult[nLength] = '\0';

    return pszStaticResult;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5255
movl %eax, %ebp
callq 0x5287
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movslq %ebp, %rcx
movl %eax, %edx
cmpl %eax, %ebp
jge 0x5397
movslq %eax, %rdx
cmpb $0x2e, (%rbx,%rdx)
je 0x5397
decq %rdx
cmpq %rcx, %rdx
jg 0x5387
movl %ebp, %edx
cmpl %ebp, %edx
cmovnel %edx, %eax
subl %ebp, %eax
addq %rcx, %rbx
movslq %eax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2160
movb $0x0, (%r14,%r15)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_path.cpp
// Function: CPLGetExtension
const char *CPLGetExtension( const char *pszFullFilename )

{
    int iFileStart = CPLFindFilenameStart( pszFullFilename );
    int iExtStart;
    char *pszStaticResult = CPLGetStaticResult();

    for( iExtStart = strlen(pszFullFilename);
         iExtStart > iFileStart && pszFullFilename[iExtStart] != '.';
         iExtStart-- ) {}

    if( iExtStart == iFileStart )
        iExtStart = strlen(pszFullFilename)-1;

    strncpy( pszStaticResult, pszFullFilename+iExtStart+1, CPL_PATH_BUF_SIZE );
    pszStaticResult[CPL_PATH_BUF_SIZE - 1] = '\0';

    return pszStaticResult;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x5255
movl %eax, %ebp
callq 0x5287
movq %rax, %rbx
movq %r14, %rdi
callq 0x2120
movl %eax, %ecx
cmpl %eax, %ebp
jge 0x5400
movslq %eax, %rcx
movslq %ebp, %rdx
cmpb $0x2e, (%r14,%rcx)
je 0x5400
decq %rcx
cmpq %rdx, %rcx
jg 0x53ef
movl %ebp, %ecx
decl %eax
cmpl %ebp, %ecx
cmovnel %ecx, %eax
cltq
leaq (%r14,%rax), %rsi
incq %rsi
movl $0x800, %edx            # imm = 0x800
movq %rbx, %rdi
callq 0x2160
movb $0x0, 0x7ff(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq