LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0x1a47e(%rip), %eax     # 0x1f650
cmpl $0x0, %eax
jle 0x5215
cmpq $0x0, -0x8(%rbp)
jne 0x51fb
movl 0x1a46c(%rip), %edx     # 0x1f650
leaq 0x1418b(%rip), %rdi     # 0x19376
leaq 0x14269(%rip), %rsi     # 0x1945b
movb $0x0, %al
callq 0x5a00
jmp 0x5213
movq -0x8(%rbp), %rdi
movl 0x1a44b(%rip), %edx     # 0x1f650
leaq 0x1424f(%rip), %rsi     # 0x1945b
movb $0x0, %al
callq 0x2410
jmp 0x5215
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl 0x1a42b(%rip), %ecx     # 0x1f650
cmpl %ecx, %eax
jge 0x5319
cmpq $0x0, -0x8(%rbp)
jne 0x52a1
movq 0x1a41d(%rip), %rax     # 0x1f658
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x8(%rax), %edx
movq 0x1a408(%rip), %rax     # 0x1f658
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0xc(%rax), %ecx
movq 0x1a3f3(%rip), %rax     # 0x1f658
movslq -0xc(%rbp), %rsi
shlq $0x5, %rsi
addq %rsi, %rax
movq 0x18(%rax), %r8
movq 0x1a3dd(%rip), %rax     # 0x1f658
movslq -0xc(%rbp), %rsi
shlq $0x5, %rsi
addq %rsi, %rax
movq 0x10(%rax), %r9
leaq 0x140e5(%rip), %rdi     # 0x19376
leaq 0x141d9(%rip), %rsi     # 0x19471
movb $0x0, %al
callq 0x5a00
jmp 0x5309
movq -0x8(%rbp), %rdi
movq 0x1a3ac(%rip), %rax     # 0x1f658
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x8(%rax), %edx
movq 0x1a397(%rip), %rax     # 0x1f658
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0xc(%rax), %ecx
movq 0x1a382(%rip), %rax     # 0x1f658
movslq -0xc(%rbp), %rsi
shlq $0x5, %rsi
addq %rsi, %rax
movq 0x18(%rax), %r8
movq 0x1a36c(%rip), %rax     # 0x1f658
movslq -0xc(%rbp), %rsi
shlq $0x5, %rsi
addq %rsi, %rax
movq 0x10(%rax), %r9
leaq 0x1416f(%rip), %rsi     # 0x19471
movb $0x0, %al
callq 0x2410
jmp 0x530b
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x521c
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2120
cmpq $0x0, %rax
jne 0x56de
leaq 0x15316(%rip), %rax     # 0x1a9f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2440
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x5728
jmp 0x56f3
movq -0x10(%rbp), %rdi
callq 0x2450
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x571d
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x13, %rsi
callq 0x72e0
movq %rax, -0x20(%rbp)
jmp 0x56f3
movq -0x10(%rbp), %rdi
callq 0x24b0
jmp 0x572a
jmp 0x572a
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x5, %edi
callq 0x6700
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x59e9
movl $0x208, %edi            # imm = 0x208
movl $0x1, %esi
callq 0x2fc0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x1f4, 0x10(%rax)      # imm = 0x1F4
movq -0x8(%rbp), %rsi
movl $0x5, %edi
movl $0x1, %edx
callq 0x6760
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rurban[P]dgnlib/cpl_error.cpp
// Function: CPLErrorReset
void CPL_STDCALL CPLErrorReset()
{
    CPLErrorContext *psCtx = CPLGetErrorContext();

    psCtx->nLastErrNo = CPLE_None;
    psCtx->szLastErrMsg[0] = '\0';
    psCtx->eLastErrType = CE_None;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x5990
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
cmpb $0x0, 0x1988f(%rip)     # 0x1f678
jne 0x5e19
leaq 0x19886(%rip), %rdi     # 0x1f678
callq 0x2510
cmpl $0x0, %eax
je 0x5e19
movq 0x191dd(%rip), %rax     # 0x1efe0
movq (%rax), %rax
movq %rax, 0x19863(%rip)     # 0x1f670
leaq 0x19864(%rip), %rdi     # 0x1f678
callq 0x21b0
cmpl $0x0, 0x19848(%rip)     # 0x1f668
jne 0x5e9b
movl $0x1, 0x1983c(%rip)     # 0x1f668
movq 0x191ad(%rip), %rax     # 0x1efe0
movq (%rax), %rax
movq %rax, 0x19833(%rip)     # 0x1f670
leaq 0x13725(%rip), %rdi     # 0x19569
xorl %eax, %eax
movl %eax, %esi
callq 0x40b0
cmpq $0x0, %rax
je 0x5e99
leaq 0x1370f(%rip), %rdi     # 0x19569
leaq 0x13e23(%rip), %rsi     # 0x19c84
callq 0x40b0
movq %rax, %rdi
leaq 0x13701(%rip), %rsi     # 0x19571
callq 0x2350
movq %rax, 0x197f4(%rip)     # 0x1f670
cmpq $0x0, 0x197ec(%rip)     # 0x1f670
jne 0x5e97
movq 0x19153(%rip), %rax     # 0x1efe0
movq (%rax), %rax
movq %rax, 0x197d9(%rip)     # 0x1f670
jmp 0x5e99
jmp 0x5e9b
cmpl $0x1, -0x4(%rbp)
jne 0x5ebc
movq 0x197c8(%rip), %rdi     # 0x1f670
movq -0x10(%rbp), %rdx
leaq 0x136db(%rip), %rsi     # 0x1958e
movb $0x0, %al
callq 0x2410
jmp 0x5efe
cmpl $0x2, -0x4(%rbp)
jne 0x5ee0
movq 0x197a7(%rip), %rdi     # 0x1f670
movl -0x8(%rbp), %edx
movq -0x10(%rbp), %rcx
leaq 0x1369d(%rip), %rsi     # 0x19574
movb $0x0, %al
callq 0x2410
jmp 0x5efc
movq 0x19789(%rip), %rdi     # 0x1f670
movl -0x8(%rbp), %edx
movq -0x10(%rbp), %rcx
leaq 0x1368f(%rip), %rsi     # 0x19584
movb $0x0, %al
callq 0x2410
jmp 0x5efe
movq 0x1976b(%rip), %rdi     # 0x1f670
callq 0x2340
addq $0x10, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0x190dd(%rip), %rax     # 0x1f2d0
movq %rax, -0x10(%rbp)
callq 0x5990
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6220
leaq 0x13164(%rip), %rdi     # 0x19376
leaq 0x1338d(%rip), %rsi     # 0x195a6
movb $0x0, %al
callq 0x5a00
leaq -0x30(%rbp), %rdi
leaq 0x19435(%rip), %rsi     # 0x1f660
movsd 0x12fed(%rip), %xmm0    # 0x19220
leaq 0x13306(%rip), %rdx     # 0x19540
movl $0x26b, %ecx            # imm = 0x26B
callq 0x6370
movq 0x19085(%rip), %rax     # 0x1f2d0
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x19079(%rip)     # 0x1f2d0
jne 0x6269
leaq -0x490(%rip), %rax      # 0x5dd0
movq %rax, 0x19069(%rip)     # 0x1f2d0
jmp 0x6274
movq -0x8(%rbp), %rax
movq %rax, 0x1905c(%rip)     # 0x1f2d0
leaq -0x30(%rbp), %rdi
callq 0x6390
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x5990
movq %rax, -0x10(%rbp)
movl $0x10, %edi
callq 0x9fb0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: rurban[P]dgnlib/cpl_error.cpp
// Function: CPLPopErrorHandler
void CPL_STDCALL CPLPopErrorHandler()

{
    CPLErrorContext *psCtx = CPLGetErrorContext();

    if( psCtx->psHandlerStack != NULL )
    {
        CPLErrorHandlerNode     *psNode = psCtx->psHandlerStack;

        psCtx->psHandlerStack = psNode->psNext;
        VSIFree( psNode );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x5990
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6320
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0xa000
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2120
movq %rax, %rdi
addq $0x1e, %rdi
callq 0x3040
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x13204(%rip), %rsi     # 0x1965d
movb $0x0, %al
callq 0x20a0
movq -0x28(%rbp), %rdi
leaq 0x12ba0(%rip), %rsi     # 0x1900b
callq 0x2350
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x29(%rbp)
je 0x6492
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
seta %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x649b
jmp 0x6507
movq -0x20(%rbp), %rdi
callq 0x22f0
movsd 0x131a4(%rip), %xmm0    # 0x19650
ucomisd -0x18(%rbp), %xmm0
jbe 0x64bf
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x64ce
movsd 0x13189(%rip), %xmm0    # 0x19650
movsd %xmm0, -0x38(%rbp)
jmp 0x64ce
movsd -0x38(%rbp), %xmm0
callq 0x6590
movsd -0x18(%rbp), %xmm0
movsd 0x1316b(%rip), %xmm1    # 0x19650
subsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x12b12(%rip), %rsi     # 0x1900b
callq 0x2350
movq %rax, -0x20(%rbp)
jmp 0x6474
cmpq $0x0, -0x20(%rbp)
je 0x652a
movq -0x20(%rbp), %rdi
callq 0x22f0
movq -0x28(%rbp), %rdi
callq 0xa000
movq $0x0, -0x8(%rbp)
jmp 0x6583
movq -0x28(%rbp), %rdi
leaq 0x12fd6(%rip), %rsi     # 0x1950b
callq 0x2350
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6558
movq -0x28(%rbp), %rdi
callq 0xa000
movq $0x0, -0x8(%rbp)
jmp 0x6583
movq -0x20(%rbp), %rcx
leaq 0x13102(%rip), %rdi     # 0x19665
movl $0x1, %esi
movl $0x5, %edx
callq 0x2550
movq -0x20(%rbp), %rdi
callq 0x22f0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x22a0
movq -0x10(%rbp), %rax
movsd 0x1309e(%rip), %xmm0    # 0x19650
addsd -0x8(%rbp), %xmm0
cvttsd2si %xmm0, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x65dc
jmp 0x65d1
leaq -0x10(%rbp), %rdi
callq 0x22a0
jmp 0x65c5
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rurban[P]dgnlib/cpl_multiproc.cpp
// Function: CPLUnlockFile
void CPLUnlockFile( void *hLock )

{
    char *pszLockFilename = (char *) hLock;

    if( hLock == NULL )
        return;
    
    VSIUnlink( pszLockFilename );
    
    CPLFree( pszLockFilename );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x660d
jmp 0x661f
movq -0x10(%rbp), %rdi
callq 0x9a50
movq -0x10(%rbp), %rdi
callq 0xa000
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rurban[P]dgnlib/cpl_multiproc.cpp
// Function: CPLCleanupTLSList(void**)
static void CPLCleanupTLSList( void **papTLSList )

{
    int i;

//    printf( "CPLCleanupTLSList(%p)\n", papTLSList );
    
    if( papTLSList == NULL )
        return;

    for( i = 0; i < CTLS_MAX; i++ )
    {
        if( papTLSList[i] != NULL && papTLSList[i+CTLS_MAX] != NULL )
        {
            CPLFree( papTLSList[i] );
        }
    }

    CPLFree( papTLSList );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6695
jmp 0x66ec
movl $0x0, -0xc(%rbp)
cmpl $0x20, -0xc(%rbp)
jge 0x66e3
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x66d6
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x20, %ecx
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x66d6
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xa000
jmp 0x66d8
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x669c
movq -0x8(%rbp), %rdi
callq 0xa000
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6870
movl %eax, -0x14(%rbp)
callq 0x68f0
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x67f1
movq -0x20(%rbp), %rdi
leaq 0x134a2(%rip), %rsi     # 0x19c84
callq 0x22c0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6859
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x2160
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cmpl $0x1, -0x14(%rbp)
jle 0x6851
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x6840
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0x6851
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2120
movl %eax, -0xc(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0xd(%rbp)
jle 0x68c8
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x2f, %ecx
movb %al, -0xd(%rbp)
je 0x68c8
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x68d1
jmp 0x68de
jmp 0x68d3
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6888
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x7, %edi
callq 0x6700
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x692e
movl $0x800, %edi            # imm = 0x800
callq 0x3040
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movl $0x7, %edi
movl $0x1, %edx
callq 0x6760
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6870
movl %eax, -0xc(%rbp)
callq 0x68f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rax
addq %rax, %rsi
movl $0x800, %edx            # imm = 0x800
callq 0x2160
movq -0x18(%rbp), %rax
movb $0x0, 0x7ff(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6870
movl %eax, -0xc(%rbp)
callq 0x68f0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2120
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %ecx
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0x21(%rbp)
jle 0x6a9f
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x6aa8
jmp 0x6ab5
jmp 0x6aaa
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6a7d
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x6ac9
movq -0x8(%rbp), %rdi
callq 0x2120
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rax
addq %rax, %rsi
movslq -0x14(%rbp), %rdx
callq 0x2160
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6870
movl %eax, -0xc(%rbp)
callq 0x68f0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2120
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %ecx
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0x19(%rbp)
jle 0x6b4f
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x6b58
jmp 0x6b65
jmp 0x6b5a
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6b2d
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x6b7d
movq -0x8(%rbp), %rdi
callq 0x2120
subq $0x1, %rax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0x10(%rbp), %rax
addq %rax, %rsi
addq $0x1, %rsi
movl $0x800, %edx            # imm = 0x800
callq 0x2160
movq -0x18(%rbp), %rax
movb $0x0, 0x7ff(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x68f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x800, %edx            # imm = 0x800
callq 0x2160
movq -0x18(%rbp), %rax
movb $0x0, 0x7ff(%rax)
movq -0x18(%rbp), %rdi
callq 0x2120
subq $0x1, %rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x6c5d
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x6c1b
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x6c5d
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x6c4e
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
je 0x6c4e
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
jne 0x6c50
jmp 0x6c5d
jmp 0x6c52
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6bf6
movq -0x18(%rbp), %rdi
leaq 0x13d88(%rip), %rsi     # 0x1a9f0
callq 0x2500
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2500
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x68f0
movq %rax, -0x20(%rbp)
leaq 0x12fd0(%rip), %rax     # 0x19c84
movq %rax, -0x28(%rbp)
leaq 0x12fc5(%rip), %rax     # 0x19c84
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6cd7
leaq 0x12fb3(%rip), %rax     # 0x19c84
movq %rax, -0x8(%rbp)
jmp 0x6d3d
movq -0x8(%rbp), %rdi
callq 0x2120
cmpq $0x0, %rax
jbe 0x6d3b
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2120
movq %rax, %rcx
movq -0x38(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x6d3b
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2120
movq %rax, %rcx
movq -0x40(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
je 0x6d3b
leaq 0x12934(%rip), %rax     # 0x1966b
movq %rax, -0x28(%rbp)
jmp 0x6d3d
cmpq $0x0, -0x18(%rbp)
jne 0x6d51
leaq 0x12f39(%rip), %rax     # 0x19c84
movq %rax, -0x18(%rbp)
jmp 0x6d79
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0x6d77
movq -0x18(%rbp), %rdi
callq 0x2120
cmpq $0x0, %rax
jbe 0x6d77
leaq 0x13c7d(%rip), %rax     # 0x1a9f0
movq %rax, -0x30(%rbp)
jmp 0x6d79
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x800, %edx            # imm = 0x800
callq 0x2160
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x800, %edx            # imm = 0x800
callq 0x21e0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x800, %edx            # imm = 0x800
callq 0x21e0
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl $0x800, %edx            # imm = 0x800
callq 0x21e0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x800, %edx            # imm = 0x800
callq 0x21e0
movq -0x20(%rbp), %rax
movb $0x0, 0x7ff(%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x68f0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7110
cmpl $0x0, %eax
jne 0x7054
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7103
cmpq $0x0, -0x10(%rbp)
je 0x706a
movq -0x10(%rbp), %rdi
callq 0x2120
cmpq $0x0, %rax
jne 0x7077
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7103
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x800, %edx            # imm = 0x800
callq 0x2160
movq -0x20(%rbp), %rax
movb $0x0, 0x7ff(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2120
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x70ee
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2120
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
je 0x70ee
movq -0x20(%rbp), %rdi
leaq 0x12582(%rip), %rsi     # 0x1966b
callq 0x2500
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2500
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2120
cmpq $0x2, %rax
jbe 0x7149
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
leaq 0x1253a(%rip), %rsi     # 0x19674
movl $0x2, %edx
callq 0x2150
cmpl $0x0, %eax
je 0x7161
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
je 0x7161
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x716a
movl $0x0, -0x4(%rbp)
jmp 0x7171
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7308
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x737f
cmpq $0x0, -0x10(%rbp)
jne 0x7324
movl $0x2, %edi
movl $0x8, %esi
callq 0x2fc0
movq %rax, -0x10(%rbp)
jmp 0x734a
movq -0x10(%rbp), %rdi
callq 0x7390
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x2, %eax
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x3120
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31e0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: rurban[P]dgnlib/cpl_string.cpp
// Function: CSLCount
int CSLCount(char **papszStrList)
{
    int nItems=0;

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

    return nItems;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x73cb
jmp 0x73a8
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x73c9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x73a8
jmp 0x73cb
movl -0xc(%rbp), %eax
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x73e8
cmpl $0x0, -0x14(%rbp)
jge 0x73f5
leaq 0x12895(%rip), %rax     # 0x19c84
movq %rax, -0x8(%rbp)
jmp 0x7442
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x7432
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x7425
leaq 0x12865(%rip), %rax     # 0x19c84
movq %rax, -0x8(%rbp)
jmp 0x7442
jmp 0x7427
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x73fc
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7498
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x748f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xa000
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x746b
movq -0x8(%rbp), %rdi
callq 0xa000
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7390
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x74c8
movq $0x0, -0x8(%rbp)
jmp 0x753b
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x3040
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7528
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
jmp 0x74ee
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x757d
cmpq $0x0, -0x18(%rbp)
je 0x757d
movq -0x18(%rbp), %rdi
callq 0x74a0
movq %rax, -0x8(%rbp)
jmp 0x75f6
cmpq $0x0, -0x18(%rbp)
jne 0x758e
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x75f6
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x75ee
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7600
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x7780
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa000
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7595
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x7764
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3d, %eax
je 0x7652
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
jne 0x7754
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x29(%rbp)
je 0x7686
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x768f
jmp 0x769d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x7665
cmpq $0x0, -0x18(%rbp)
je 0x774a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x3040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x2160
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x2a(%rbp)
jle 0x7725
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x2b(%rbp)
je 0x771f
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x2b(%rbp)
movb -0x2b(%rbp), %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x772e
jmp 0x7748
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x76e3
jmp 0x774a
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x776c
jmp 0x7756
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7617
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x11ad2(%rip), %rsi     # 0x19421
callq 0x9af0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x79b2
jmp 0x7961
movq -0x10(%rbp), %rdi
callq 0x9c60
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x7978
jmp 0x799e
movq -0x10(%rbp), %rdi
callq 0x3690
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x799c
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x72e0
movq %rax, -0x20(%rbp)
jmp 0x7961
movq -0x10(%rbp), %rdi
callq 0x9b20
xorl %eax, %eax
movl %eax, %edi
callq 0x3690
jmp 0x79e5
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x2040
movl (%rax), %edi
callq 0x20d0
movq -0x28(%rbp), %rcx
movq %rax, %r8
movl $0x3, %edi
movl $0x4, %esi
leaq 0x11c99(%rip), %rdx     # 0x19677
movb $0x0, %al
callq 0x5740
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7aed
movq -0x10(%rbp), %rdi
leaq 0x11b54(%rip), %rsi     # 0x19571
callq 0x9c80
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x7ab8
jmp 0x7a32
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7aad
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x9f20
cmpl $-0x1, %eax
je 0x7a64
movq -0x18(%rbp), %rsi
movl $0xa, %edi
callq 0x9f50
cmpl $-0x1, %eax
jne 0x7a96
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x2040
movl (%rax), %edi
callq 0x20d0
movq -0x28(%rbp), %rcx
movq %rax, %r8
movl $0x3, %esi
leaq 0x11bfc(%rip), %rdx     # 0x19687
movl %esi, %edi
movb $0x0, %al
callq 0x5740
jmp 0x7aad
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x7a32
movq -0x18(%rbp), %rdi
callq 0x9cb0
jmp 0x7aeb
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x2040
movl (%rax), %edi
callq 0x20d0
movq -0x30(%rbp), %rcx
movq %rax, %r8
movl $0x3, %edi
movl $0x4, %esi
leaq 0x11ba3(%rip), %rdx     # 0x19687
movb $0x0, %al
callq 0x5740
jmp 0x7aed
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7b2c
movq 0x174a3(%rip), %rax     # 0x1efc8
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7b71
jmp 0x7b35
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7b6f
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0x11a3d(%rip), %rsi     # 0x1958e
movb $0x0, %al
callq 0x9e60
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x7b35
jmp 0x7b71
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)