LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa7d1(%rip), %xmm0     # 0xe220
callq 0x24f0
mulsd 0xa7cc(%rip), %xmm0     # 0xe228
movapd %xmm0, (%rsp)
movapd 0xa7e7(%rip), %xmm2     # 0xe250
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 0xa78d(%rip), %xmm1     # 0xe230
cvttsd2si %xmm1, %r14d
imull $0xe10, %ebp, %r12d     # imm = 0xE10
imull $0x3c, %r14d, %r13d
leaq 0xa94d(%rip), %rsi      # 0xe407
movq %r15, %rdi
callq 0x22e0
movapd 0x30(%rsp), %xmm0
ucomisd 0x10(%rsp), %xmm0
cvtsi2sd %r12d, %xmm0
movsd 0xa75d(%rip), %xmm1     # 0xe238
movapd 0x20(%rsp), %xmm3
mulsd %xmm1, %xmm3
subsd %xmm0, %xmm3
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 0xb1fe(%rip), %rcx      # 0xed15
leaq 0xb1eb(%rip), %rdx      # 0xed09
cmovaq %rcx, %rdx
leaq 0xb1fb(%rip), %rsi      # 0xed24
leaq 0xb1c4(%rip), %rcx      # 0xecf4
cmovaq %rsi, %rcx
orpd %xmm0, %xmm2
movapd %xmm2, (%rsp)
testl %eax, %eax
cmovneq %rdx, %rcx
leaq 0xa8c2(%rip), %rsi      # 0xe40c
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x20a0
leaq 0x117ae(%rip), %rbx     # 0x15310
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_O2/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 0xa6b0(%rip), %xmm2     # 0xe250
movapd %xmm2, 0x30(%rsp)
maxsd %xmm0, %xmm2
movapd %xmm2, (%rsp)
movapd %xmm2, %xmm0
divsd 0xa685(%rip), %xmm0     # 0xe240
callq 0x24e0
movapd %xmm0, 0x10(%rsp)
movsd 0xa672(%rip), %xmm1     # 0xe240
mulsd %xmm0, %xmm1
movapd (%rsp), %xmm0
subsd %xmm1, %xmm0
movapd %xmm0, (%rsp)
divsd 0xa628(%rip), %xmm0     # 0xe210
callq 0x24e0
movapd %xmm0, %xmm1
movapd 0xa657(%rip), %xmm3     # 0xe250
xorpd %xmm3, %xmm1
mulsd 0xa62b(%rip), %xmm0     # 0xe230
unpcklpd 0x10(%rsp), %xmm1       # xmm1 = xmm1[0],mem[0]
movapd (%rsp), %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
mulpd 0xa644(%rip), %xmm1     # 0xe260
addpd %xmm2, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
xorpd %xmm2, %xmm3
movapd 0x20(%rsp), %xmm0
cmpltsd 0x30(%rsp), %xmm0
movapd %xmm0, %xmm1
andnpd %xmm2, %xmm1
andpd %xmm3, %xmm0
orpd %xmm1, %xmm0
divsd 0xa5e3(%rip), %xmm0     # 0xe238
addq $0x48, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa5e0(%rip), %xmm2     # 0xe250
movapd %xmm2, 0x30(%rsp)
maxsd %xmm0, %xmm2
movapd %xmm2, (%rsp)
movapd %xmm2, %xmm0
callq 0x24e0
movapd %xmm0, 0x10(%rsp)
movapd (%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
movsd 0xa58c(%rip), %xmm0     # 0xe230
mulsd %xmm1, %xmm0
callq 0x24e0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd 0xa5b7(%rip), %xmm0     # 0xe270
movapd 0x10(%rsp), %xmm1
unpcklpd (%rsp), %xmm1           # xmm1 = xmm1[0],mem[0]
mulpd 0xa5b4(%rip), %xmm1     # 0xe280
addpd %xmm0, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movapd 0xa56c(%rip), %xmm3     # 0xe250
xorpd %xmm0, %xmm3
movapd 0x20(%rsp), %xmm2
cmpltsd 0x30(%rsp), %xmm2
movapd %xmm2, %xmm1
andnpd %xmm0, %xmm1
andpd %xmm3, %xmm2
orpd %xmm1, %xmm2
movapd %xmm2, %xmm0
addq $0x48, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3d1f
movq %r14, %rdi
callq 0x2390
movsd %xmm0, (%r15)
andq $0x0, (%rbx)
pushq $-0x1
popq %rax
xorl %edx, %edx
movl %eax, %ecx
movb (%r14,%rdx), %sil
testb %sil, %sil
je 0x3d75
cmpq $0x63, %rdx
ja 0x3d75
cmpb $0x20, %sil
je 0x3d75
leal -0x2b(%rsi), %edi
testb $-0x3, %dil
movl %eax, %edi
cmovel %edx, %edi
testq %rdx, %rdx
cmovnel %edi, %eax
cmpb $0x69, %sil
cmovel %edx, %ecx
incq %rdx
jmp 0x3d42
testl %eax, %eax
js 0x3d92
testl %ecx, %ecx
js 0x3d92
cmpl %ecx, %eax
jge 0x3d92
movl %eax, %eax
addq %rax, %r14
movq %r14, %rdi
callq 0x2390
movsd %xmm0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x1129b(%rip)     # 0x15350
jle 0x40ea
movl 0x11293(%rip), %edx     # 0x15350
testq %rbx, %rbx
je 0x40d5
leaq 0xa391(%rip), %rsi      # 0xe45a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2410
jmp 0x40ea
leaq 0xa2ca(%rip), %rdi      # 0xe3a6
leaq 0xa377(%rip), %rsi      # 0xe45a
xorl %eax, %eax
callq 0x45a8
pushq $0x18
popq %r12
leaq 0xa2b1(%rip), %r14      # 0xe3a6
leaq 0xa374(%rip), %r15      # 0xe470
xorl %r13d, %r13d
movslq 0x1124a(%rip), %rax     # 0x15350
cmpq %rax, %r13
jge 0x414f
movq 0x11246(%rip), %rax     # 0x15358
movl -0x10(%rax,%r12), %edx
movl -0xc(%rax,%r12), %ecx
movq (%rax,%r12), %r8
movq -0x8(%rax,%r12), %r9
testq %rbx, %rbx
je 0x4139
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2410
jmp 0x4146
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x45a8
incq %r13
addq $0x20, %r12
jmp 0x40ff
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbaf2(%rip), %rax      # 0xfe40
cmoveq %rax, %rdi
callq 0x2440
testq %rax, %rax
je 0x438c
movq %rax, %r14
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x2450
testq %rax, %rax
je 0x4382
addq $0x13, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54dc
movq %rax, %rbx
jmp 0x4361
movq %r14, %rdi
callq 0x24c0
jmp 0x438e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x5
popq %rdi
callq 0x4dfd
movq %rax, %rbx
testq %rax, %rax
jne 0x45a3
pushq $0x1
popq %rsi
movl $0x208, %edi            # imm = 0x208
callq 0x2c6c
movq %rax, %rbx
andl $0x0, 0x4(%rax)
movl $0x1f4, 0x10(%rax)      # imm = 0x1F4
pushq $0x5
popq %rdi
pushq $0x1
popq %rdx
movq %rax, %rsi
callq 0x4e33
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10b48(%rip), %al      # 0x15378
testb %al, %al
je 0x48fc
cmpb $0x0, 0x10b29(%rip)     # 0x15368
jne 0x48a4
movb $0x1, 0x10b20(%rip)     # 0x15368
movq 0x10791(%rip), %r15     # 0x14fe0
movq (%r15), %rax
movq %rax, 0x10b17(%rip)     # 0x15370
leaq 0x9d09(%rip), %rdi      # 0xe569
xorl %esi, %esi
callq 0x367f
testq %rax, %rax
je 0x48a4
leaq 0x9cf6(%rip), %rdi      # 0xe569
leaq 0xa772(%rip), %rsi      # 0xefec
callq 0x367f
leaq 0x9ceb(%rip), %rsi      # 0xe571
movq %rax, %rdi
callq 0x2340
movq %rax, 0x10adb(%rip)     # 0x15370
testq %rax, %rax
jne 0x48a4
movq (%r15), %rax
movq %rax, 0x10acc(%rip)     # 0x15370
movq 0x10ac5(%rip), %rdi     # 0x15370
cmpl $0x2, %r14d
je 0x48ca
cmpl $0x1, %r14d
jne 0x48d3
leaq 0x9cd0(%rip), %rsi      # 0xe58e
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2410
jmp 0x48e6
leaq 0x9ca3(%rip), %rsi      # 0xe574
jmp 0x48da
leaq 0x9caa(%rip), %rsi      # 0xe584
movl %ebp, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2410
movq 0x10a83(%rip), %rdi     # 0x15370
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2330
leaq 0x10a75(%rip), %rdi     # 0x15378
callq 0x2520
testl %eax, %eax
je 0x4838
movq 0x106c9(%rip), %rax     # 0x14fe0
movq (%rax), %rax
movq %rax, 0x10a4f(%rip)     # 0x15370
leaq 0x10a50(%rip), %rdi     # 0x15378
callq 0x21a0
jmp 0x4838
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4569
cmpq $0x0, 0x8(%rax)
je 0x4b7d
leaq 0x9837(%rip), %rdi      # 0xe3a6
leaq 0x9a2d(%rip), %rsi      # 0xe5a3
xorl %eax, %eax
callq 0x45a8
leaq 0x107dc(%rip), %rsi     # 0x15360
leaq 0x99b5(%rip), %rdx      # 0xe540
leaq 0x8(%rsp), %r14
movsd 0x9678(%rip), %xmm0     # 0xe210
movq %r14, %rdi
movl $0x26b, %ecx            # imm = 0x26B
callq 0x4c40
movq 0x10724(%rip), %r15     # 0x152d0
testq %r15, %r15
leaq -0x39b(%rip), %rax      # 0x481b
cmoveq %rax, %rbx
movq %rbx, 0x1070f(%rip)     # 0x152d0
movq %r14, %rdi
callq 0x4c42
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4569
movq %rax, %r14
pushq $0x10
popq %rdi
callq 0x6a3f
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_O2/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 0x2cb3
movq %rax, %rbx
leaq 0x99e6(%rip), %rsi      # 0xe665
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x20a0
leaq 0xaa00(%rip), %r14      # 0xf693
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2340
testq %rax, %rax
movsd (%rsp), %xmm0
je 0x4ce5
ucomisd 0x99a8(%rip), %xmm0     # 0xe658
jbe 0x4ce5
movq %rax, %rdi
movsd %xmm0, (%rsp)
callq 0x22d0
movsd (%rsp), %xmm0
minsd 0x997c(%rip), %xmm0     # 0xe648
callq 0x4d3d
movsd (%rsp), %xmm0
addsd 0x9972(%rip), %xmm0     # 0xe650
movsd %xmm0, (%rsp)
jmp 0x4c93
testq %rax, %rax
je 0x4cfe
movq %rax, %rdi
callq 0x22d0
movq %rbx, %rdi
callq 0x6a49
xorl %ebx, %ebx
jmp 0x4d32
leaq 0x9805(%rip), %rsi      # 0xe50a
movq %rbx, %rdi
callq 0x2340
testq %rax, %rax
je 0x4cf2
movq %rax, %r14
leaq 0x9951(%rip), %rdi      # 0xe66d
pushq $0x1
popq %rsi
pushq $0x5
popq %rdx
movq %rax, %rcx
callq 0x2560
movq %r14, %rdi
callq 0x22d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4ebd
movl %eax, %ebp
callq 0x4eec
movq %rax, %rbx
testl %ebp, %ebp
je 0x4eac
movslq %ebp, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2150
movb $0x0, (%rbx,%r15)
cmpl $0x2, %ebp
jl 0x4eaf
movl %ebp, %ecx
leaq (%rbx,%rcx), %rax
decq %rax
movzbl -0x1(%rbx,%rcx), %ecx
cmpl $0x5c, %ecx
je 0x4eac
cmpl $0x2f, %ecx
jne 0x4eaf
movb $0x0, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rax, %rcx
movl %ecx, %edx
sarl $0x1f, %eax
andl %ecx, %eax
testl %edx, %edx
jle 0x4eea
movzbl -0x1(%rbx,%rdx), %ecx
cmpl $0x2f, %ecx
je 0x4ee8
cmpl $0x5c, %ecx
je 0x4ee8
decq %rdx
jmp 0x4ed0
movl %edx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x7
popq %rdi
callq 0x4dfd
movq %rax, %rbx
testq %rax, %rax
jne 0x4f18
movl $0x800, %edi            # imm = 0x800
callq 0x2cb3
movq %rax, %rbx
pushq $0x7
popq %rdi
pushq $0x1
popq %rdx
movq %rax, %rsi
callq 0x4e33
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4ebd
movl %eax, %ebp
callq 0x4eec
movq %rax, %r14
movslq %ebp, %rsi
addq %rbx, %rsi
movl $0x800, %edx            # imm = 0x800
movq %rax, %rdi
callq 0x2150
movb $0x0, 0x7ff(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4ebd
movl %eax, %ebp
callq 0x4eec
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movslq %eax, %rsi
movslq %ebp, %rcx
cmpl %esi, %ecx
movl %esi, %edx
cmovll %ecx, %edx
cmpq %rcx, %rsi
jle 0x4ff9
cmpb $0x2e, (%rbx,%rsi)
je 0x4ff7
decq %rsi
jmp 0x4fe7
movl %esi, %edx
cmpl %ecx, %edx
cmovnel %edx, %eax
subl %ecx, %eax
addq %rcx, %rbx
movslq %eax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2150
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_O2/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 0x4ebd
movl %eax, %ebp
callq 0x4eec
movq %rax, %rbx
movq %r14, %rdi
callq 0x2120
movslq %eax, %rdx
movslq %ebp, %rsi
cmpl %edx, %esi
movl %eax, %ecx
cmovll %esi, %ecx
cmpq %rsi, %rdx
jle 0x5065
cmpb $0x2e, (%r14,%rdx)
je 0x5063
decq %rdx
jmp 0x5052
movl %edx, %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 0x2150
movb $0x0, 0x7ff(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/rurban[P]dgnlib/cpl_path.cpp
// Function: CPLResetExtension
const char *CPLResetExtension( const char *pszPath, const char *pszExt )

{
    char *pszStaticResult = CPLGetStaticResult();
    int         i;

/* -------------------------------------------------------------------- */
/*      First, try and strip off any existing extension.                */
/* -------------------------------------------------------------------- */
    strncpy( pszStaticResult, pszPath, CPL_PATH_BUF_SIZE );
    pszStaticResult[CPL_PATH_BUF_SIZE - 1] = '\0';
    for( i = strlen(pszStaticResult) - 1; i > 0; i-- )
    {
        if( pszStaticResult[i] == '.' )
        {
            pszStaticResult[i] = '\0';
            break;
        }

        if( pszStaticResult[i] == '/' || pszStaticResult[i] == '\\' 
            || pszStaticResult[i] == ':' )
            break;
    }

/* -------------------------------------------------------------------- */
/*      Append the new extension.                                       */
/* -------------------------------------------------------------------- */
    CPLAssert( strlen(pszExt) + 2 < CPL_PATH_BUF_SIZE );
    
    strcat( pszStaticResult, "." );
    strcat( pszStaticResult, pszExt );

    return pszStaticResult;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
callq 0x4eec
movq %rax, %r14
movl $0x800, %edx            # imm = 0x800
movq %rax, %rdi
movq %r15, %rsi
callq 0x2150
movb $0x0, 0x7ff(%r14)
movq %r14, %rdi
callq 0x2120
movl %eax, %eax
decq %rax
testl %eax, %eax
jle 0x50f3
movl %eax, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movzbl (%r14,%rcx), %edx
cmpl $0x5c, %edx
je 0x50f3
cmpl $0x2f, %edx
je 0x50f3
cmpl $0x3a, %edx
je 0x50f3
cmpl $0x2e, %edx
jne 0x50c6
movb $0x0, (%r14,%rcx)
movq %r14, %rdi
callq 0x2120
movw $0x2e, (%r14,%rax)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2510
// File: /workspace/github_cpp_makefile_star2_O2/rurban[P]dgnlib/cpl_path.cpp
// Function: CPLFormFilename
const char *CPLFormFilename( const char * pszPath,
                             const char * pszBasename,
                             const char * pszExtension )

{
    char *pszStaticResult = CPLGetStaticResult();
    const char  *pszAddedPathSep = "";
    const char  *pszAddedExtSep = "";

    if( pszPath == NULL )
        pszPath = "";
    else if( strlen(pszPath) > 0
             && pszPath[strlen(pszPath)-1] != '/'
             && pszPath[strlen(pszPath)-1] != '\\' )
        pszAddedPathSep = SEP_STRING;

    if( pszExtension == NULL )
        pszExtension = "";
    else if( pszExtension[0] != '.' && strlen(pszExtension) > 0 )
        pszAddedExtSep = ".";

    CPLAssert( strlen(pszPath) + strlen(pszAddedPathSep) +
               strlen(pszBasename) + strlen(pszAddedExtSep) +
               strlen(pszExtension) + 1 < CPL_PATH_BUF_SIZE );

    strncpy( pszStaticResult, pszPath, CPL_PATH_BUF_SIZE );
    strncat( pszStaticResult, pszAddedPathSep, CPL_PATH_BUF_SIZE);
    strncat( pszStaticResult, pszBasename, CPL_PATH_BUF_SIZE);
    strncat( pszStaticResult, pszAddedExtSep, CPL_PATH_BUF_SIZE);
    strncat( pszStaticResult, pszExtension, CPL_PATH_BUF_SIZE);
    pszStaticResult[CPL_PATH_BUF_SIZE - 1] = '\0';

    return pszStaticResult;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %rbp
callq 0x4eec
movq %rax, %r14
leaq 0x9eb7(%rip), %r12      # 0xefec
movq %r12, %rsi
movq %r12, %r13
testq %rbp, %rbp
je 0x516e
movq %rbp, %rdi
callq 0x2120
testq %rax, %rax
je 0x515c
movzbl -0x1(%rbp,%rax), %eax
cmpl $0x2f, %eax
je 0x515c
cmpl $0x5c, %eax
jne 0x5164
movq %rbp, %rsi
movq %r12, %r13
jmp 0x516e
leaq 0x9508(%rip), %r13      # 0xe673
movq %rbp, %rsi
testq %rbx, %rbx
je 0x518f
movb (%rbx), %al
cmpb $0x2e, %al
je 0x5192
testb %al, %al
leaq 0x9e6a(%rip), %rax      # 0xefec
leaq 0xacb7(%rip), %r12      # 0xfe40
cmoveq %rax, %r12
jmp 0x5192
movq %r12, %rbx
movl $0x800, %edx            # imm = 0x800
movq %r14, %rdi
callq 0x2150
movl $0x800, %edx            # imm = 0x800
movq %r14, %rdi
movq %r13, %rsi
callq 0x21d0
movl $0x800, %edx            # imm = 0x800
movq %r14, %rdi
movq %r15, %rsi
callq 0x21d0
movl $0x800, %edx            # imm = 0x800
movq %r14, %rdi
movq %r12, %rsi
callq 0x21d0
movl $0x800, %edx            # imm = 0x800
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21d0
movb $0x0, 0x7ff(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/rurban[P]dgnlib/cpl_path.cpp
// Function: CPLProjectRelativeFilename
const char *CPLProjectRelativeFilename( const char *pszProjectDir, 
                                        const char *pszSecondaryFilename )

{
    char *pszStaticResult = CPLGetStaticResult();

    if( !CPLIsFilenameRelative( pszSecondaryFilename ) )
        return pszSecondaryFilename;

    if( pszProjectDir == NULL || strlen(pszProjectDir) == 0 )
        return pszSecondaryFilename;

    strncpy( pszStaticResult, pszProjectDir, CPL_PATH_BUF_SIZE );
    pszStaticResult[CPL_PATH_BUF_SIZE - 1] = '\0';

    if( pszProjectDir[strlen(pszProjectDir)-1] != '/' 
        && pszProjectDir[strlen(pszProjectDir)-1] != '\\' )
    {
        CPLAssert( strlen(SEP_STRING) + 1 < CPL_PATH_BUF_SIZE );

        strcat( pszStaticResult, SEP_STRING );
    }

    CPLAssert( strlen(pszSecondaryFilename) + 1 < CPL_PATH_BUF_SIZE );

    strcat( pszStaticResult, pszSecondaryFilename );
        
    return pszStaticResult;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
callq 0x4eec
movq %rax, %r14
movq %rbx, %rdi
callq 0x53ed
testq %r15, %r15
je 0x53e4
testl %eax, %eax
je 0x53e4
cmpb $0x0, (%r15)
je 0x53e4
movl $0x800, %edx            # imm = 0x800
movq %r14, %rdi
movq %r15, %rsi
callq 0x2150
movb $0x0, 0x7ff(%r14)
movq %r15, %rdi
callq 0x2120
movzbl -0x1(%r15,%rax), %eax
cmpl $0x2f, %eax
je 0x53d4
cmpl $0x5c, %eax
je 0x53d4
movq %r14, %rdi
callq 0x2120
movw $0x2f, (%r14,%rax)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2510
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/rurban[P]dgnlib/cpl_path.cpp
// Function: CPLIsFilenameRelative
int CPLIsFilenameRelative( const char *pszFilename )

{
    if( (strlen(pszFilename) > 2 && strncmp(pszFilename+1,":\\",2) == 0)
        || pszFilename[0] == '\\'
        || pszFilename[0] == '/' )
        return FALSE;
    else
        return TRUE;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2120
cmpq $0x3, %rax
jb 0x540a
cmpb $0x3a, 0x1(%rbx)
jne 0x540a
xorl %eax, %eax
cmpb $0x5c, 0x2(%rbx)
je 0x541b
movb (%rbx), %al
cmpb $0x5c, %al
setne %cl
cmpb $0x2f, %al
setne %al
andb %cl, %al
movzbl %al, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/rurban[P]dgnlib/cpl_string.cpp
// Function: CSLAddString
char **CSLAddString(char **papszStrList, const char *pszNewString)
{
    int nItems=0;

    if (pszNewString == NULL)
        return papszStrList;    /* Nothing to do!*/

    /* Allocate room for the new string */
    if (papszStrList == NULL)
        papszStrList = (char**) CPLCalloc(2,sizeof(char*));
    else
    {
        nItems = CSLCount(papszStrList);
        papszStrList = (char**)CPLRealloc(papszStrList, 
                                          (nItems+2)*sizeof(char*));
    }

    /* Copy the string in the list */
    papszStrList[nItems] = CPLStrdup(pszNewString);
    papszStrList[nItems+1] = NULL;

    return papszStrList;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x5536
movq %rsi, %rbx
testq %r14, %r14
je 0x5511
movq %r14, %rdi
callq 0x553e
movl %eax, %ebp
cltq
leaq 0x10(,%rax,8), %rsi
movq %r14, %rdi
callq 0x2d0a
movq %rax, %r14
jmp 0x5521
pushq $0x2
popq %rdi
pushq $0x8
popq %rsi
callq 0x2c6c
movq %rax, %r14
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x2d77
movslq %ebp, %rcx
movq %rax, (%r14,%rcx,8)
andq $0x0, 0x8(%r14,%rcx,8)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/rurban[P]dgnlib/cpl_string.cpp
// Function: CSLGetField
const char * CSLGetField( char ** papszStrList, int iField )

{
    int         i;

    if( papszStrList == NULL || iField < 0 )
        return( "" );

    for( i = 0; i < iField+1; i++ )
    {
        if( papszStrList[i] == NULL )
            return "";
    }

    return( papszStrList[iField] );
}

// Assembly:
testq %rdi, %rdi
sete %al
testl %esi, %esi
sets %cl
orb %al, %cl
leaq 0x9a86(%rip), %rax      # 0xefec
jne 0x557d
leal 0x1(%rsi), %ecx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x557e
cmpq $0x0, (%rdi,%rdx,8)
leaq 0x1(%rdx), %rdx
jne 0x556d
retq
movl %esi, %eax
movq (%rdi,%rax,8), %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/rurban[P]dgnlib/cpl_string.cpp
// Function: CSLDestroy
void CPL_STDCALL CSLDestroy(char **papszStrList)
{
    char **papszPtr;

    if (papszStrList)
    {
        papszPtr = papszStrList;
        while(*papszPtr != NULL)
        {
            CPLFree(*papszPtr);
            papszPtr++;
        }

        CPLFree(papszStrList);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x55b6
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0x55a7
callq 0x6a49
addq $0x8, %r14
jmp 0x5594
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6a49
retq
// File: /workspace/github_cpp_makefile_star2_O2/rurban[P]dgnlib/cpl_string.cpp
// Function: CSLDuplicate
char    **CSLDuplicate(char **papszStrList)
{
    char **papszNewList, **papszSrc, **papszDst;
    int  nLines;

    nLines = CSLCount(papszStrList);

    if (nLines == 0)
        return NULL;

    papszNewList = (char **)CPLMalloc((nLines+1)*sizeof(char*));
    papszSrc = papszStrList;
    papszDst = papszNewList;

    while(*papszSrc != NULL)
    {
        *papszDst = CPLStrdup(*papszSrc);

        papszSrc++;
        papszDst++;
    }
    *papszDst = NULL;

    return papszNewList;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x553e
testl %eax, %eax
je 0x55fc
cltq
leaq 0x8(,%rax,8), %rdi
callq 0x2cb3
movq %rax, %r14
xorl %r15d, %r15d
movq (%rbx,%r15), %rdi
testq %rdi, %rdi
je 0x55f5
callq 0x2d77
movq %rax, (%r14,%r15)
addq $0x8, %r15
jmp 0x55dd
andq $0x0, (%r14,%r15)
jmp 0x55ff
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/rurban[P]dgnlib/cpl_string.cpp
// Function: CSLMerge
char **CSLMerge( char **papszOrig, char **papszOverride )

{
    int i;

    if( papszOrig == NULL && papszOverride != NULL )
        return CSLDuplicate( papszOverride );
    
    if( papszOverride == NULL )
        return papszOrig;

    for( i = 0; papszOverride[i] != NULL; i++ )
    {
        char *pszKey = NULL;
        const char *pszValue = CPLParseNameValue( papszOverride[i], &pszKey );

        papszOrig = CSLSetNameValue( papszOrig, pszKey, pszValue );
        CPLFree( pszKey );
    }

    return papszOrig;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x5635
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x55b7
movq %rdi, %rbx
testq %r14, %r14
je 0x567b
leaq 0x8(%rsp), %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x567b
andq $0x0, 0x8(%rsp)
movq %r15, %rsi
callq 0x5688
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x5723
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x6a49
addq $0x8, %r14
jmp 0x5642
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/rurban[P]dgnlib/cpl_string.cpp
// Function: CPLParseNameValue
const char *CPLParseNameValue(const char *pszNameValue, char **ppszKey )

{
    int  i;
    const char *pszValue;

    for( i = 0; pszNameValue[i] != '\0'; i++ )
    {
        if( pszNameValue[i] == '=' || pszNameValue[i] == ':' )
        {
            pszValue = pszNameValue + i + 1;
            while( *pszValue == ' ' || *pszValue == '\t' )
                pszValue++;

            if( ppszKey != NULL )
            {
                *ppszKey = (char *) CPLMalloc(i+1);
                strncpy( *ppszKey, pszNameValue, i );
                (*ppszKey)[i] = '\0';
                while( i > 0 && 
                       ( (*ppszKey)[i] == ' ' || (*ppszKey)[i] == '\t') )
                {
                    (*ppszKey)[i] = '\0';
                    i--;
                }
            }

            return pszValue;
        }
    }

    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r12
leaq 0x1(%rdi), %rbx
xorl %r15d, %r15d
movzbl (%r12,%r15), %eax
testl %eax, %eax
je 0x5712
cmpl $0x3d, %eax
je 0x56b5
cmpl $0x3a, %eax
je 0x56b5
incq %r15
jmp 0x569d
addq %r15, %rbx
movzbl (%rbx), %eax
cmpl $0x20, %eax
je 0x56c5
cmpl $0x9, %eax
jne 0x56ca
incq %rbx
jmp 0x56b8
testq %r14, %r14
je 0x5714
leal 0x1(%r15), %edi
callq 0x2cb3
movq %rax, (%r14)
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2150
movq (%r14), %rax
movb $0x0, (%rax,%r15)
testq %r15, %r15
jle 0x5714
movq (%r14), %rax
movzbl (%rax,%r15), %ecx
cmpl $0x20, %ecx
je 0x5708
cmpl $0x9, %ecx
jne 0x5714
movb $0x0, (%rax,%r15)
decq %r15
jmp 0x56f1
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/rurban[P]dgnlib/cpl_string.cpp
// Function: CSLSetNameValue
char **CSLSetNameValue(char **papszList, 
                       const char *pszName, const char *pszValue)
{
    char **papszPtr;
    int nLen;

    if (pszName == NULL )
        return papszList;

    nLen = strlen(pszName);
    papszPtr = papszList;
    while(papszPtr && *papszPtr != NULL)
    {
        if (EQUALN(*papszPtr, pszName, nLen)
            && ( (*papszPtr)[nLen] == '=' || 
                 (*papszPtr)[nLen] == ':' ) )
        {
            /* Found it!  
             * Change the value... make sure to keep the ':' or '='
             */
            char cSep;
            cSep = (*papszPtr)[nLen];

            CPLFree(*papszPtr);

            /* 
             * If the value is NULL, remove this entry completely/
             */
            if( pszValue == NULL )
            {
                while( papszPtr[1] != NULL )
                {
                    *papszPtr = papszPtr[1];
                    papszPtr++;
                }
                *papszPtr = NULL;
            }

            /*
             * Otherwise replace with new value.
             */
            else
            {
                *papszPtr = (char *) CPLMalloc(strlen(pszName)+strlen(pszValue)+2);
                sprintf( *papszPtr, "%s%c%s", pszName, cSep, pszValue );
            }
            return papszList;
        }
        papszPtr++;
    }

    if( pszValue == NULL )
        return papszList;

    /* The name does not exist yet... create a new entry
     */
    return CSLAddNameValue(papszList, pszName, pszValue);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
testq %rsi, %rsi
je 0x5809
movq %rsi, %r15
movq %rdx, (%rsp)
movq %rsi, %rdi
callq 0x2120
movslq %eax, %r12
movq %r14, %rbx
testq %rbx, %rbx
je 0x5784
movq (%rbx), %r13
testq %r13, %r13
je 0x5784
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x23b0
testl %eax, %eax
jne 0x577e
movzbl (%r13,%r12), %ebp
cmpl $0x3d, %ebp
je 0x57a6
cmpl $0x3a, %ebp
je 0x57a6
addq $0x8, %rbx
jmp 0x574f
movq (%rsp), %rdx
testq %rdx, %rdx
je 0x5809
movq %r14, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x61a8
movq %r13, %rdi
callq 0x6a49
movq (%rsp), %r13
testq %r13, %r13
je 0x57fc
movq %r15, %rdi
callq 0x2120
movq %rax, %r12
movq %r13, %rdi
callq 0x2120
leaq (%r12,%rax), %rdi
addq $0x2, %rdi
callq 0x2cb3
movq %rax, (%rbx)
leaq 0x8ee0(%rip), %rsi      # 0xe6c1
movq %rax, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %r13, %r8
xorl %eax, %eax
callq 0x20a0
jmp 0x5809
movq %rax, (%rbx)
addq $0x8, %rbx
movq 0x8(%rbx), %rax
testq %rax, %rax
jne 0x57f5
andq $0x0, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/rurban[P]dgnlib/cpl_string.cpp
// Function: CSLLoad
char **CSLLoad(const char *pszFname)
{
    FILE        *fp;
    const char  *pszLine;
    char        **papszStrList=NULL;

    fp = VSIFOpenL(pszFname, "rb");

    if (fp)
    {
        while(!VSIFEofL(fp))
        {
            if ( (pszLine = CPLReadLineL(fp)) != NULL )
            {
                papszStrList = CSLAddString(papszStrList, pszLine);
            }
        }

        VSIFCloseL(fp);

        CPLReadLineL( NULL );
    }
    else
    {
        /* Unable to open file */
        CPLError(CE_Failure, CPLE_OpenFailed,
                 "CSLLoad(%s): %s", pszFname, strerror(errno));
    }

    return papszStrList;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
leaq 0x8bf6(%rip), %rsi      # 0xe420
callq 0x6935
testq %rax, %rax
je 0x5873
movq %rax, %r14
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x6969
testl %eax, %eax
jne 0x5862
movq %r14, %rdi
callq 0x3084
testq %rax, %rax
je 0x5839
movq %rbx, %rdi
movq %rax, %rsi
callq 0x54dc
movq %rax, %rbx
jmp 0x5839
movq %r14, %rdi
callq 0x693a
xorl %edi, %edi
callq 0x3084
jmp 0x589b
callq 0x2040
movl (%rax), %edi
callq 0x20d0
leaq 0x8e0a(%rip), %rdx      # 0xe690
xorl %ebx, %ebx
pushq $0x3
popq %rdi
pushq $0x4
popq %rsi
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x439c
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/rurban[P]dgnlib/cpl_string.cpp
// Function: CSLSave
int  CSLSave(char **papszStrList, const char *pszFname)
{
    FILE    *fp;
    int     nLines = 0;

    if (papszStrList)
    {
        if ((fp = VSIFOpen(pszFname, "wt")) != NULL)
        {
            while(*papszStrList != NULL)
            {
                if (VSIFPuts(*papszStrList, fp) == EOF ||
                    VSIFPutc('\n', fp) == EOF)
                {
                    CPLError(CE_Failure, CPLE_FileIO,
                             "CSLSave(%s): %s", pszFname, 
                             strerror(errno));
                    break;  /* A Problem happened... abort */
                }

                nLines++;
                papszStrList++;
            }

            VSIFClose(fp);
        }
        else
        {
            /* Unable to open file */
            CPLError(CE_Failure, CPLE_OpenFailed,
                     "CSLSave(%s): %s", pszFname, strerror(errno));
        }
    }

    return nLines;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x58fe
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x8cb3(%rip), %rsi      # 0xe571
movq %rbx, %rdi
callq 0x6970
testq %rax, %rax
je 0x5932
movq %rax, %r15
xorl %r14d, %r14d
pushq $0xa
popq %rbp
movq (%r12,%r14,8), %rdi
testq %rdi, %rdi
je 0x5928
movq %r15, %rsi
callq 0x6a30
cmpl $-0x1, %eax
je 0x5903
movl %ebp, %edi
movq %r15, %rsi
callq 0x6a35
cmpl $-0x1, %eax
je 0x5903
incq %r14
jmp 0x58d4
xorl %r14d, %r14d
jmp 0x595b
callq 0x2040
movl (%rax), %edi
callq 0x20d0
leaq 0x8d8a(%rip), %rdx      # 0xe6a0
pushq $0x3
popq %rdi
movl %edi, %esi
movq %rbx, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x439c
movq %r15, %rdi
callq 0x6975
jmp 0x595b
callq 0x2040
movl (%rax), %edi
callq 0x20d0
leaq 0x8d5b(%rip), %rdx      # 0xe6a0
xorl %r14d, %r14d
pushq $0x3
popq %rdi
pushq $0x4
popq %rsi
movq %rbx, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x439c
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/rurban[P]dgnlib/cpl_string.cpp
// Function: CSLPrint
int  CSLPrint(char **papszStrList, FILE *fpOut)
{
    int     nLines=0;

    if (fpOut == NULL)
        fpOut = stdout;

    if (papszStrList)
    {
        while(*papszStrList != NULL)
        {
            VSIFPrintf(fpOut, "%s\n", *papszStrList);
            nLines++;
            papszStrList++;
        }
    }

    return nLines;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
jne 0x5984
movq 0xf647(%rip), %rax      # 0x14fc8
movq (%rax), %r14
testq %rbx, %rbx
je 0x59ae
leaq 0x8bfe(%rip), %r12      # 0xe58e
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdx
testq %rdx, %rdx
je 0x59b1
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x69a7
incq %r15
jmp 0x5993
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/rurban[P]dgnlib/cpl_string.cpp
// Function: CSLInsertStrings
char **CSLInsertStrings(char **papszStrList, int nInsertAtLineNo, 
                        char **papszNewLines)
{
    int     i, nSrcLines, nDstLines, nToInsert;
    char    **ppszSrc, **ppszDst;

    if (papszNewLines == NULL ||
        ( nToInsert = CSLCount(papszNewLines) ) == 0)
        return papszStrList;    /* Nothing to do!*/

    nSrcLines = CSLCount(papszStrList);
    nDstLines = nSrcLines + nToInsert;

    /* Allocate room for the new strings */
    papszStrList = (char**)CPLRealloc(papszStrList, 
                                      (nDstLines+1)*sizeof(char*));

    /* Make sure the array is NULL-terminated... it may not be if
     * papszStrList was NULL before Realloc()
     */
    papszStrList[nSrcLines] = NULL;

    /* Make some room in the original list at the specified location 
     * Note that we also have to move the NULL pointer at the end of
     * the source StringList.
     */
    if (nInsertAtLineNo == -1 || nInsertAtLineNo > nSrcLines)
        nInsertAtLineNo = nSrcLines;

    ppszSrc = papszStrList + nSrcLines;
    ppszDst = papszStrList + nDstLines;

    for (i=nSrcLines; i>=nInsertAtLineNo; i--)
    {
        *ppszDst = *ppszSrc;
        ppszDst--;
        ppszSrc--;
    }

    /* Copy the strings to the list */
    ppszSrc = papszNewLines;
    ppszDst = papszStrList + nInsertAtLineNo;

    for (; *ppszSrc != NULL; ppszSrc++, ppszDst++)
    {
        *ppszDst = CPLStrdup(*ppszSrc);
    }
    
    return papszStrList;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
testq %rdx, %rdx
je 0x5a5b
movq %rdx, %r14
movl %esi, %ebp
movq %rdx, %rdi
callq 0x553e
testl %eax, %eax
je 0x5a5b
movl %eax, %r15d
movq %rbx, %rdi
callq 0x553e
movl %eax, %r12d
leal (%r12,%r15), %eax
cltq
leaq 0x8(,%rax,8), %rsi
movq %rbx, %rdi
callq 0x2d0a
movq %rax, %rbx
movslq %r12d, %rax
andq $0x0, (%rbx,%rax,8)
cmpl %ebp, %eax
movl %ebp, %ecx
cmovll %eax, %ecx
cmpl $-0x1, %ebp
cmovel %eax, %ecx
movslq %r15d, %rdx
leaq (%rbx,%rdx,8), %rdx
cmpl %ecx, %eax
jl 0x5a39
movq (%rbx,%rax,8), %rsi
movq %rsi, (%rdx,%rax,8)
decq %rax
jmp 0x5a28
movslq %ecx, %rax
leaq (%rbx,%rax,8), %r15
xorl %r12d, %r12d
movq (%r14,%r12), %rdi
testq %rdi, %rdi
je 0x5a5b
callq 0x2d77
movq %rax, (%r15,%r12)
addq $0x8, %r12
jmp 0x5a43
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/rurban[P]dgnlib/cpl_string.cpp
// Function: CSLFindString
int CSLFindString( char ** papszList, const char * pszTarget )

{
    int         i;

    if( papszList == NULL )
        return -1;

    for( i = 0; papszList[i] != NULL; i++ )
    {
        if( EQUAL(papszList[i],pszTarget) )
            return i;
    }

    return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
pushq $-0x1
popq %rbx
testq %rdi, %rdi
je 0x5ba2
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
testq %rdi, %rdi
je 0x5ba2
movq %r14, %rsi
callq 0x22e0
testl %eax, %eax
je 0x5b9f
incq %r12
jmp 0x5b85
movl %r12d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq