LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5287
movq %rax, %r14
movl $0x800, %edx            # imm = 0x800
movq %rax, %rdi
movq %r15, %rsi
callq 0x2160
movb $0x0, 0x7ff(%r14)
movq %r14, %rdi
callq 0x2120
movl %eax, %eax
decq %rax
testl %eax, %eax
jle 0x5497
movl %eax, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movzbl (%r14,%rdx), %ecx
cmpl $0x39, %ecx
jg 0x5486
cmpl $0x2e, %ecx
je 0x5492
cmpl $0x2f, %ecx
jne 0x5461
jmp 0x5497
cmpl $0x3a, %ecx
je 0x5497
cmpl $0x5c, %ecx
jne 0x5461
jmp 0x5497
movb $0x0, (%r14,%rdx)
movq %r14, %rdi
callq 0x2120
movw $0x2e, (%r14,%rax)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2520
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5287
movq %rax, %r14
leaq 0xbadb(%rip), %r12      # 0x10fb4
movq %r12, %rsi
movq %r12, %r13
testq %rbp, %rbp
je 0x5512
movq %rbp, %rdi
callq 0x2120
testq %rax, %rax
je 0x5500
movzbl -0x1(%rbp,%rax), %eax
cmpl $0x2f, %eax
je 0x5500
cmpl $0x5c, %eax
jne 0x5508
movq %rbp, %rsi
movq %r12, %r13
jmp 0x5512
leaq 0xb144(%rip), %r13      # 0x10653
movq %rbp, %rsi
testq %rbx, %rbx
je 0x5533
movb (%rbx), %al
cmpb $0x2e, %al
je 0x5536
testb %al, %al
leaq 0xba8e(%rip), %rax      # 0x10fb4
leaq 0xc843(%rip), %r12      # 0x11d70
cmoveq %rax, %r12
jmp 0x5536
movq %r12, %rbx
movl $0x800, %edx            # imm = 0x800
movq %r14, %rdi
callq 0x2160
movl $0x800, %edx            # imm = 0x800
movq %r14, %rdi
movq %r13, %rsi
callq 0x21e0
movl $0x800, %edx            # imm = 0x800
movq %r14, %rdi
movq %r15, %rsi
callq 0x21e0
movl $0x800, %edx            # imm = 0x800
movq %r14, %rdi
movq %r12, %rsi
callq 0x21e0
movl $0x800, %edx            # imm = 0x800
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21e0
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_O1/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 0x5287
movq %rax, %r14
movq %rbx, %rdi
callq 0x57a4
testq %r15, %r15
je 0x579b
testl %eax, %eax
je 0x579b
cmpb $0x0, (%r15)
je 0x579b
movl $0x800, %edx            # imm = 0x800
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
movb $0x0, 0x7ff(%r14)
movq %r15, %rdi
callq 0x2120
movzbl -0x1(%r15,%rax), %eax
cmpl $0x2f, %eax
je 0x578b
cmpl $0x5c, %eax
je 0x578b
movq %r14, %rdi
callq 0x2120
movw $0x2f, (%r14,%rax)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2520
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x57cc
leaq 0x1(%rbx), %rdi
leaq 0xae9e(%rip), %rsi      # 0x1065c
movl $0x2, %edx
callq 0x2150
testl %eax, %eax
je 0x57df
movb (%rbx), %al
cmpb $0x5c, %al
setne %cl
cmpb $0x2f, %al
setne %al
andb %cl, %al
movzbl %al, %eax
popq %rbx
retq
xorl %eax, %eax
jmp 0x57dd
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x5918
movq %rsi, %r14
testq %rbx, %rbx
je 0x58d0
cmpq $0x0, (%rbx)
je 0x58e7
xorl %r15d, %r15d
cmpq $0x0, 0x8(%rbx,%r15,8)
leaq 0x1(%r15), %r15
jne 0x58c2
jmp 0x58ea
movl $0x2, %edi
movl $0x8, %esi
callq 0x2d54
movq %rax, %rbx
xorl %r15d, %r15d
jmp 0x5900
xorl %r15d, %r15d
movslq %r15d, %rax
leaq 0x10(,%rax,8), %rsi
movq %rbx, %rdi
callq 0x2df9
movq %rax, %rbx
movq %r14, %rdi
callq 0x2e6c
movslq %r15d, %rcx
movq %rax, (%rbx,%rcx,8)
movq $0x0, 0x8(%rbx,%rcx,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb663(%rip), %rax      # 0x10fb4
jne 0x596d
leal 0x1(%rsi), %ecx
xorl %edx, %edx
cmpq $0x0, (%rdi,%rdx,8)
je 0x596d
incq %rdx
cmpq %rdx, %rcx
jne 0x5958
movl %esi, %eax
movq (%rdi,%rax,8), %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x59a6
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x5997
leaq 0x8(%rbx), %r14
callq 0x701d
movq (%r14), %rdi
addq $0x8, %r14
testq %rdi, %rdi
jne 0x5986
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x701d
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
xorl %eax, %eax
testq %rdi, %rdi
je 0x59ca
cmpq $0x0, (%rbx)
je 0x59ca
xorl %eax, %eax
cmpq $0x0, 0x8(%rbx,%rax,8)
leaq 0x1(%rax), %rax
jne 0x59be
testl %eax, %eax
je 0x5a13
cltq
leaq 0x8(,%rax,8), %rdi
callq 0x2d9b
movq %rax, %r14
movq (%rbx), %rdi
movq %rax, %r15
testq %rdi, %rdi
je 0x5a0a
addq $0x8, %rbx
movq %r14, %r15
callq 0x2e6c
movq %rax, (%r15)
addq $0x8, %r15
movq (%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
jne 0x59f2
movq $0x0, (%r15)
jmp 0x5a16
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5a4c
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x59a7
movq %rdi, %rbx
testq %r14, %r14
je 0x5a9f
movq (%r14), %rdi
testq %rdi, %rdi
je 0x5a9f
addq $0x8, %r14
leaq 0x8(%rsp), %r15
movq $0x0, 0x8(%rsp)
movq %r15, %rsi
callq 0x5aac
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x5b6a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x701d
movq (%r14), %rdi
addq $0x8, %r14
testq %rdi, %rdi
jne 0x5a65
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r12
movq $-0x1, %r13
xorl %r15d, %r15d
movzbl (%r12,%r15), %eax
testl %eax, %eax
je 0x5b55
cmpl $0x3d, %eax
je 0x5ae6
cmpl $0x3a, %eax
je 0x5ae6
incq %r15
decq %r13
jmp 0x5ac7
movq %r13, %rbp
negq %rbp
movq %r12, %r14
subq %r13, %r14
movzbl (%r14), %eax
cmpl $0x20, %eax
je 0x5b00
cmpl $0x9, %eax
jne 0x5b05
incq %r14
jmp 0x5af2
testq %rbx, %rbx
je 0x5b58
movl %r13d, %edi
negl %edi
callq 0x2d9b
movq %rax, (%rbx)
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2160
movq (%rbx), %rax
movb $0x0, (%rax,%r15)
cmpq $-0x1, %r13
je 0x5b58
movq (%rbx), %rax
movzbl -0x1(%rax,%rbp), %ecx
cmpl $0x20, %ecx
je 0x5b45
cmpl $0x9, %ecx
jne 0x5b58
movb $0x0, -0x1(%rax,%rbp)
decq %rbp
cmpq $0x1, %rbp
jg 0x5b33
jmp 0x5b58
xorl %r14d, %r14d
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_O1/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, %rbp
testq %rsi, %rsi
je 0x5c6e
movq %rsi, %r15
movq %rdx, (%rsp)
testq %rbp, %rbp
je 0x5bd4
movq %r15, %rdi
callq 0x2120
movq (%rbp), %r12
testq %r12, %r12
je 0x5bd4
movslq %eax, %r13
movq %rbp, %rbx
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x23c0
testl %eax, %eax
jne 0x5bc7
movzbl (%r12,%r13), %r14d
cmpl $0x3d, %r14d
je 0x5bfa
cmpl $0x3a, %r14d
je 0x5bfa
movq 0x8(%rbx), %r12
addq $0x8, %rbx
testq %r12, %r12
jne 0x5ba4
movq (%rsp), %rdx
testq %rdx, %rdx
je 0x5c6e
movq %rbp, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x66fa
movq %r12, %rdi
callq 0x701d
movq (%rsp), %rax
testq %rax, %rax
je 0x5c51
movsbl %r14b, %r13d
movq %r15, %rdi
movq %rax, %r14
callq 0x2120
movq %rax, %r12
movq %r14, %rdi
callq 0x2120
leaq (%r12,%rax), %rdi
addq $0x2, %rdi
callq 0x2d9b
movq %rax, (%rbx)
leaq 0xaa69(%rip), %rsi      # 0x106a5
movq %rax, %rdi
movq %r15, %rdx
movl %r13d, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x20a0
jmp 0x5c6e
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x5c67
movq %rax, (%rbx)
movq 0x10(%rbx), %rax
addq $0x8, %rbx
jmp 0x5c55
movq $0x0, (%rbx)
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_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 0xa771(%rip), %rsi      # 0x10400
callq 0x6f09
testq %rax, %rax
je 0x5ce0
movq %rax, %r14
movq %rax, %rdi
callq 0x6f3d
xorl %ebx, %ebx
testl %eax, %eax
jne 0x5ccf
movq %r14, %rdi
callq 0x319e
testq %rax, %rax
je 0x5cc5
movq %rbx, %rdi
movq %rax, %rsi
callq 0x58a4
movq %rax, %rbx
movq %r14, %rdi
callq 0x6f3d
jmp 0x5ca6
movq %r14, %rdi
callq 0x6f0e
xorl %edi, %edi
callq 0x319e
jmp 0x5d0c
callq 0x2040
movl (%rax), %edi
callq 0x20d0
leaq 0xa981(%rip), %rdx      # 0x10674
xorl %ebx, %ebx
movl $0x3, %edi
movl $0x4, %esi
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x46dc
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5d78
movq %rsi, %rbx
movq %rdi, %r12
leaq 0xa822(%rip), %rsi      # 0x10551
movq %rbx, %rdi
callq 0x6f44
testq %rax, %rax
je 0x5d7d
movq %rax, %r15
movq (%r12), %rdi
xorl %r14d, %r14d
testq %rdi, %rdi
je 0x5dd6
movq %r15, %rsi
callq 0x7004
cmpl $-0x1, %eax
je 0x5dac
movl $0xa, %edi
movq %r15, %rsi
callq 0x7009
cmpl $-0x1, %eax
je 0x5dac
movq 0x8(%r12,%r14,8), %rdi
incq %r14
jmp 0x5d46
xorl %r14d, %r14d
jmp 0x5dde
callq 0x2040
movl (%rax), %edi
callq 0x20d0
leaq 0xa8f4(%rip), %rdx      # 0x10684
xorl %r14d, %r14d
movl $0x3, %edi
movl $0x4, %esi
movq %rbx, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x46dc
jmp 0x5dde
callq 0x2040
movl (%rax), %edi
callq 0x20d0
leaq 0xa8c5(%rip), %rdx      # 0x10684
movl $0x3, %edi
movl $0x3, %esi
movq %rbx, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x46dc
movq %r15, %rdi
callq 0x6f49
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5e0a
movq 0x101c1(%rip), %rax     # 0x15fc8
movq (%rax), %r14
xorl %r15d, %r15d
testq %rbx, %rbx
je 0x5e3e
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x5e3e
leaq 0xa74d(%rip), %r12      # 0x1056e
xorl %r15d, %r15d
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x6f7b
movq 0x8(%rbx,%r15,8), %rdx
incq %r15
testq %rdx, %rdx
jne 0x5e24
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
testq %rdx, %rdx
je 0x5f1c
movq %rdx, %rbx
movl %esi, %ebp
cmpq $0x0, (%rdx)
je 0x5e7d
xorl %r15d, %r15d
cmpq $0x0, 0x8(%rbx,%r15,8)
leaq 0x1(%r15), %r15
jne 0x5e6f
jmp 0x5e80
xorl %r15d, %r15d
testl %r15d, %r15d
je 0x5f1c
xorl %r12d, %r12d
testq %r14, %r14
je 0x5ea7
cmpq $0x0, (%r14)
je 0x5ea7
xorl %r12d, %r12d
cmpq $0x0, 0x8(%r14,%r12,8)
leaq 0x1(%r12), %r12
jne 0x5e9a
leal (%r12,%r15), %eax
cltq
leaq 0x8(,%rax,8), %rsi
movq %r14, %rdi
callq 0x2df9
movslq %r12d, %rdx
cmpl %ebp, %edx
movl %ebp, %ecx
cmovll %edx, %ecx
movq %rax, %r14
cmpl $-0x1, %ebp
cmovel %edx, %ecx
movq $0x0, (%rax,%rdx,8)
movslq %r15d, %rax
leaq (%r14,%rax,8), %rax
leal 0x1(%rdx), %esi
movq (%r14,%rdx,8), %rdi
movq %rdi, (%rax,%rdx,8)
decq %rdx
decl %esi
cmpl %ecx, %esi
jg 0x5ee2
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5f1c
movslq %ecx, %rax
leaq (%r14,%rax,8), %r15
xorl %r12d, %r12d
callq 0x2e6c
movq %rax, (%r15,%r12)
movq 0x8(%rbx,%r12), %rdi
addq $0x8, %r12
testq %rdi, %rdi
jne 0x5f05
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x6097
movq %rdi, %r15
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x6097
movq %rsi, %r14
xorl %r12d, %r12d
movq %r14, %rsi
callq 0x22f0
testl %eax, %eax
je 0x6094
movq 0x8(%r15,%r12,8), %rdi
incq %r12
testq %rdi, %rdi
jne 0x6079
jmp 0x6097
movl %r12d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_string.cpp
// Function: CPLSPrintf
const char *CPLSPrintf(char *fmt, ...)
{
    va_list args;

    va_start(args, fmt);
#if defined(HAVE_VSNPRINTF)
    vsnprintf(gszCPLSPrintfBuffer[gnCPLSPrintfBuffer], CPLSPrintf_BUF_SIZE-1,
              fmt, args);
#else
    vsprintf(gszCPLSPrintfBuffer[gnCPLSPrintfBuffer], fmt, args);
#endif
    va_end(args);
    
   int nCurrent = gnCPLSPrintfBuffer;

    if (++gnCPLSPrintfBuffer == CPLSPrintf_BUF_Count)
      gnCPLSPrintfBuffer = 0;

    return gszCPLSPrintfBuffer[nCurrent];
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x6400
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rcx
movq %rdi, 0x10(%rcx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rcx)
movslq 0x237f9(%rip), %rax     # 0x29c20
imulq $0x1f40, %rax, %rdi     # imm = 0x1F40
leaq 0xff6b(%rip), %rbx      # 0x163a0
addq %rbx, %rdi
movl $0x1f3f, %esi           # imm = 0x1F3F
movq %r10, %rdx
callq 0x21a0
movslq 0x237d4(%rip), %rax     # 0x29c20
leal 0x1(%rax), %ecx
xorl %edx, %edx
cmpl $0xa, %ecx
cmovnel %ecx, %edx
movl %edx, 0x237c3(%rip)     # 0x29c20
imulq $0x1f40, %rax, %rax     # imm = 0x1F40
addq %rbx, %rax
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_string.cpp
// Function: CSLAppendPrintf
char **CSLAppendPrintf(char **papszStrList, char *fmt, ...)
{
    va_list args;

    va_start(args, fmt);
#if defined(HAVE_VSNPRINTF)
    vsnprintf(gszCPLSPrintfBuffer[gnCPLSPrintfBuffer], CPLSPrintf_BUF_SIZE-1,
              fmt, args);
#else
    vsprintf(gszCPLSPrintfBuffer[gnCPLSPrintfBuffer], fmt, args);
#endif
    va_end(args);

    int nCurrent = gnCPLSPrintfBuffer;

    if (++gnCPLSPrintfBuffer == CPLSPrintf_BUF_Count)
      gnCPLSPrintfBuffer = 0;

    return CSLAddString(papszStrList, gszCPLSPrintfBuffer[nCurrent]);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r10
movq %rdi, %rbx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x64d0
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rcx
movq %rsi, 0x10(%rcx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rcx)
movslq 0x23729(%rip), %rax     # 0x29c20
imulq $0x1f40, %rax, %rdi     # imm = 0x1F40
leaq 0xfe9b(%rip), %r14      # 0x163a0
addq %r14, %rdi
movl $0x1f3f, %esi           # imm = 0x1F3F
movq %r10, %rdx
callq 0x21a0
movslq 0x23704(%rip), %rax     # 0x29c20
leal 0x1(%rax), %ecx
xorl %edx, %edx
cmpl $0xa, %ecx
cmovnel %ecx, %edx
movl %edx, 0x236f3(%rip)     # 0x29c20
imulq $0x1f40, %rax, %rsi     # imm = 0x1F40
addq %r14, %rsi
movq %rbx, %rdi
callq 0x58a4
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_string.cpp
// Function: CSLTestBoolean
int CSLTestBoolean( const char *pszValue )
{
    if( EQUAL(pszValue,"NO")
        || EQUAL(pszValue,"FALSE") 
        || EQUAL(pszValue,"OFF") 
        || EQUAL(pszValue,"0") )
        return FALSE;
    else
        return TRUE;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0xa13c(%rip), %rsi      # 0x10694
callq 0x22f0
xorl %ebx, %ebx
testl %eax, %eax
je 0x659f
leaq 0xa12d(%rip), %rsi      # 0x10697
movq %r14, %rdi
callq 0x22f0
testl %eax, %eax
je 0x659f
leaq 0x9ff5(%rip), %rsi      # 0x10572
movq %r14, %rdi
callq 0x22f0
testl %eax, %eax
je 0x659f
leaq 0xa10d(%rip), %rsi      # 0x1069d
movq %r14, %rdi
callq 0x22f0
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_string.cpp
// Function: CSLFetchBoolean
int CSLFetchBoolean( char **papszStrList, const char *pszKey, int bDefault )

{
    const char *pszValue;

    if( CSLFindString( papszStrList, pszKey ) != -1 )
        return TRUE;

    pszValue = CSLFetchNameValue(papszStrList, pszKey );
    if( pszValue == NULL )
        return bDefault;
    else 
        return CSLTestBoolean( pszValue );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x6056
movl %eax, %ecx
movl $0x1, %eax
cmpl $-0x1, %ecx
je 0x65cd
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
callq 0x65ec
movq %rax, %rdi
movl %ebx, %eax
testq %rdi, %rdi
je 0x65c7
popq %rbx
popq %r14
popq %r15
jmp 0x654a
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_string.cpp
// Function: CSLFetchNameValue
const char *CSLFetchNameValue(char **papszStrList, const char *pszName)
{
    int nLen;

    if (papszStrList == NULL || pszName == NULL)
        return NULL;

    nLen = strlen(pszName);
    while(*papszStrList != NULL)
    {
        if (EQUALN(*papszStrList, pszName, nLen)
            && ( (*papszStrList)[nLen] == '=' || 
                 (*papszStrList)[nLen] == ':' ) )
        {
            return (*papszStrList)+nLen+1;
        }
        papszStrList++;
    }
    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x6654
movq %rdi, %r14
movq (%rdi), %r12
testq %r12, %r12
je 0x6654
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x2120
movslq %eax, %r13
addq $0x8, %r14
xorl %r15d, %r15d
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x23c0
testl %eax, %eax
jne 0x6646
movzbl (%r12,%r13), %eax
cmpl $0x3d, %eax
je 0x6664
cmpl $0x3a, %eax
je 0x6664
movq (%r14), %r12
addq $0x8, %r14
testq %r12, %r12
jne 0x6625
jmp 0x6657
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq (%r12,%r13), %r15
incq %r15
jmp 0x6657
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_string.cpp
// Function: CSLFetchNameValueMultiple
char **CSLFetchNameValueMultiple(char **papszStrList, const char *pszName)
{
    int nLen;
    char **papszValues = NULL;

    if (papszStrList == NULL || pszName == NULL)
        return NULL;

    nLen = strlen(pszName);
    while(*papszStrList != NULL)
    {
        if (EQUALN(*papszStrList, pszName, nLen)
            && ( (*papszStrList)[nLen] == '=' || 
                 (*papszStrList)[nLen] == ':' ) )
        {
            papszValues = CSLAddString(papszValues, 
                                          (*papszStrList)+nLen+1);
        }
        papszStrList++;
    }

    return papszValues;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x66ea
movq %rdi, %r14
movq (%rdi), %r13
testq %r13, %r13
je 0x66ea
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x2120
movslq %eax, %r12
addq $0x8, %r14
xorl %r15d, %r15d
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x23c0
testl %eax, %eax
jne 0x66dc
movzbl (%r13,%r12), %eax
cmpl $0x3d, %eax
je 0x66c8
cmpl $0x3a, %eax
jne 0x66dc
addq %r12, %r13
incq %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x58a4
movq %rax, %r15
movq (%r14), %r13
addq $0x8, %r14
testq %r13, %r13
jne 0x66a6
jmp 0x66ed
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_string.cpp
// Function: CSLAddNameValue
char **CSLAddNameValue(char **papszStrList, 
                    const char *pszName, const char *pszValue)
{
    char *pszLine;

    if (pszName == NULL || pszValue==NULL)
        return papszStrList;

    pszLine = (char *) CPLMalloc(strlen(pszName)+strlen(pszValue)+2);
    sprintf( pszLine, "%s=%s", pszName, pszValue );
    papszStrList = CSLAddString(papszStrList, pszLine);
    CPLFree( pszLine );

    return papszStrList;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x676b
movq %rdx, %r14
movq %rsi, %r15
movq %rsi, %rdi
callq 0x2120
movq %rax, %r12
movq %r14, %rdi
callq 0x2120
leaq (%r12,%rax), %rdi
addq $0x2, %rdi
callq 0x2d9b
movq %rax, %r12
leaq 0x9f5a(%rip), %rsi      # 0x1069f
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x20a0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x58a4
movq %rax, %rbx
movq %r12, %rdi
callq 0x701d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_string.cpp
// Function: CSLSetNameValueSeparator
void CSLSetNameValueSeparator( char ** papszList, const char *pszSeparator )

{
    int         nLines = CSLCount(papszList), iLine;

    for( iLine = 0; iLine < nLines; iLine++ )
    {
        char        *pszKey = NULL;
        const char  *pszValue;
        char        *pszNewLine;

        pszValue = CPLParseNameValue( papszList[iLine], &pszKey );
        
        pszNewLine = (char *) CPLMalloc( strlen(pszValue) + strlen(pszKey)
                                         + strlen(pszSeparator) + 1 );
        strcpy( pszNewLine, pszKey );
        strcat( pszNewLine, pszSeparator );
        strcat( pszNewLine, pszValue );
        CPLFree( papszList[iLine] );
        papszList[iLine] = pszNewLine;
        CPLFree( pszKey );
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
testq %rdi, %rdi
je 0x67a9
cmpq $0x0, (%r14)
je 0x67a9
xorl %eax, %eax
cmpq $0x0, 0x8(%r14,%rax,8)
leaq 0x1(%rax), %rax
jne 0x679d
testl %eax, %eax
jle 0x684f
movl %eax, %eax
movq %rax, 0x10(%rsp)
xorl %r15d, %r15d
movq $0x0, 0x8(%rsp)
movq (%r14,%r15,8), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5aac
movq %rax, %r12
movq %rax, %rdi
callq 0x2120
movq %rax, %r13
movq 0x8(%rsp), %rdi
callq 0x2120
movq %rax, %rbp
movq %rbx, %rdi
callq 0x2120
addq %r13, %rbp
leaq (%rax,%rbp), %rdi
incq %rdi
callq 0x2d9b
movq %rax, %r13
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x22b0
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2520
movq %r13, %rdi
movq %r12, %rsi
callq 0x2520
movq (%r14,%r15,8), %rdi
callq 0x701d
movq %r13, (%r14,%r15,8)
movq 0x8(%rsp), %rdi
callq 0x701d
incq %r15
cmpq %r15, 0x10(%rsp)
jne 0x67bb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_string.cpp
// Function: CPLBinaryToHex
char *CPLBinaryToHex( int nBytes, const GByte *pabyData )

{
    char *pszHex = (char *) CPLMalloc(nBytes * 2 + 1 );
    int i;
    static const char achHex[] = "0123456789ABCDEF";

    pszHex[nBytes*2] = '\0';

    for( i = 0; i < nBytes; i++ )
    {
        int nLow = pabyData[i] & 0x0f;
        int nHigh = (pabyData[i] & 0xf0) >> 4;

        pszHex[i*2] = achHex[nHigh];
        pszHex[i*2+1] = achHex[nLow];
    }

    return pszHex;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movslq %edi, %r14
leaq (%r14,%r14), %rax
incl %eax
movslq %eax, %rdi
callq 0x2d9b
movb $0x0, (%rax,%r14,2)
testl %r14d, %r14d
jle 0x6e3b
movl %ebp, %ecx
xorl %edx, %edx
leaq 0x993c(%rip), %rsi      # 0x10750
movzbl (%rbx,%rdx), %edi
movl %edi, %r8d
andl $0xf, %r8d
shrl $0x4, %edi
movb (%rdi,%rsi), %dil
movb %dil, (%rax,%rdx,2)
movb (%r8,%rsi), %dil
movb %dil, 0x1(%rax,%rdx,2)
incq %rdx
cmpq %rdx, %rcx
jne 0x6e14
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/cpl_string.cpp
// Function: CPLHexToBinary
GByte *CPLHexToBinary( const char *pszHex, int *pnBytes )

{
    int iSrc = 0, iDst = 0, nHexLen = strlen(pszHex);

    GByte *pabyWKB;

    pabyWKB = (GByte *) CPLMalloc(nHexLen / 2 + 2);

    while( pszHex[iSrc] != '\0' )
    {
        if( pszHex[iSrc] >= '0' && pszHex[iSrc] <= '9' )
            pabyWKB[iDst] = pszHex[iSrc] - '0';
        else if( pszHex[iSrc] >= 'A' && pszHex[iSrc] <= 'F' )
            pabyWKB[iDst] = pszHex[iSrc] - 'A' + 10;
        else if( pszHex[iSrc] >= 'a' && pszHex[iSrc] <= 'f' )
            pabyWKB[iDst] = pszHex[iSrc] - 'a' + 10;
        else 
            break;

        pabyWKB[iDst] *= 16;

        iSrc++;

        if( pszHex[iSrc] >= '0' && pszHex[iSrc] <= '9' )
            pabyWKB[iDst] += pszHex[iSrc] - '0';
        else if( pszHex[iSrc] >= 'A' && pszHex[iSrc] <= 'F' )
            pabyWKB[iDst] += pszHex[iSrc] - 'A' + 10;
        else if( pszHex[iSrc] >= 'a' && pszHex[iSrc] <= 'f' )
            pabyWKB[iDst] += pszHex[iSrc] - 'a' + 10;
        else
            break;

        iSrc++;
        iDst++;
    }
    
    pabyWKB[iDst] = 0;
    *pnBytes = iDst;

    return pabyWKB;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2120
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl $0x2, %ecx
movslq %ecx, %rdi
callq 0x2d9b
movb (%r14), %dl
xorl %ecx, %ecx
testb %dl, %dl
je 0x6ee0
leal -0x30(%rdx), %edi
movb $-0x30, %sil
cmpb $0xa, %dil
jb 0x6e90
leal -0x41(%rdx), %edi
movb $-0x37, %sil
cmpb $0x6, %dil
jb 0x6e90
leal -0x61(%rdx), %edi
movb $-0x57, %sil
cmpb $0x5, %dil
ja 0x6ee0
addb %sil, %dl
shlb $0x4, %dl
movb %dl, (%rax,%rcx)
movb 0x1(%r14,%rcx,2), %sil
leal -0x30(%rsi), %edi
cmpb $0x9, %dil
ja 0x6eb0
addb %dl, %sil
addb $-0x30, %sil
jmp 0x6ed2
leal -0x41(%rsi), %edi
cmpb $0x5, %dil
ja 0x6ec2
addb %dl, %sil
addb $-0x37, %sil
jmp 0x6ed2
leal -0x61(%rsi), %edi
cmpb $0x5, %dil
ja 0x6ee0
addb %dl, %sil
addb $-0x57, %sil
movb %sil, (%rax,%rcx)
movb 0x2(%r14,%rcx,2), %dl
incq %rcx
jmp 0x6e68
movl %ecx, %edx
movb $0x0, (%rax,%rdx)
movl %ecx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/dgnhelp.cpp
// Function: DGNGetShapeFillInfo
int DGNGetShapeFillInfo( DGNHandle hDGN, DGNElemCore *psElem, int *pnColor )

{
    int iLink;
    
    for( iLink = 0; TRUE; iLink++ )
    {
        int nLinkType, nLinkSize;
        unsigned char *pabyData;

        pabyData = DGNGetLinkage( hDGN, psElem, iLink, &nLinkType, 
                                  NULL, NULL, &nLinkSize );
        if( pabyData == NULL )
            return FALSE;

        if( nLinkType == DGNLT_SHAPE_FILL && nLinkSize >= 7 )
        {
            *pnColor = pabyData[8];
            return TRUE;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
leaq 0x8(%rsp), %rbx
leaq 0xc(%rsp), %r13
movq %rbx, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
movq %r13, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x732c
testq %rax, %rax
je 0x7310
cmpl $0x41, 0xc(%rsp)
movb $0x1, %cl
jne 0x7314
cmpl $0x7, 0x8(%rsp)
jl 0x7314
movzbl 0x8(%rax), %eax
movq 0x10(%rsp), %rcx
movl %eax, (%rcx)
movl $0x1, %ebp
jmp 0x7312
xorl %ebp, %ebp
xorl %ecx, %ecx
incl %r12d
testb %cl, %cl
jne 0x72ce
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/dgnhelp.cpp
// Function: DGNGetAssocID
int DGNGetAssocID( DGNHandle hDGN, DGNElemCore *psElem )

{
    int iLink;
    
    for( iLink = 0; TRUE; iLink++ )
    {
        int nLinkType, nLinkSize;
        unsigned char *pabyData;

        pabyData = DGNGetLinkage( hDGN, psElem, iLink, &nLinkType, 
                                  NULL, NULL, &nLinkSize );
        if( pabyData == NULL )
            return -1;

        if( nLinkType == DGNLT_ASSOC_ID && nLinkSize >= 8 )
        {
            return pabyData[4] 
                + pabyData[5] * 256 
                + pabyData[6]*256*256
                + pabyData[7] * 256*256*256;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
leaq 0x14(%rsp), %r15
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %r15, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x732c
testq %rax, %rax
je 0x7458
cmpl $0x7d2f, 0x14(%rsp)     # imm = 0x7D2F
movb $0x1, %r13b
jne 0x745e
cmpl $0x8, 0x10(%rsp)
jl 0x745e
movl 0x4(%rax), %r12d
xorl %r13d, %r13d
jmp 0x745e
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
incl %ebp
testb %r13b, %r13b
jne 0x7414
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/dgnhelp.cpp
// Function: DGNRad50ToAscii(unsigned short, char*)
void DGNRad50ToAscii(unsigned short sRad50, char *str )
{
    unsigned short sValue;
    char           ch = '\0';
    unsigned short saQuots[3] = {1600,40,1};
    int i;

    for ( i=0; i<3; i++)
    {
        sValue = sRad50;
        sValue /= saQuots[i];
        /* Map 0..39 to ASCII */
        if (sValue==0)                     
            ch = ' ';          /* space */
        else if (sValue >= 1 && sValue <= 26) 
            ch = (char) (sValue-1+'A');/* printable alpha A..Z */
        else if (sValue == 27)             
            ch = '$';          /* dollar */
        else if (sValue == 28)             
            ch = '.';          /* period */
        else if (sValue == 29)             
            ch = ' ';          /* unused char, emit a space instead */
        else if (sValue >= 30 && sValue <= 39)
            ch = (char) (sValue-30+'0');   /* digit 0..9 */
        *str = ch;
        str++;

        sRad50-=(sValue*saQuots[i]);
    }

    /* Do zero-terminate */
    *str = '\0';
}

// Assembly:
movl %edi, %edx
leaq 0x9770(%rip), %rdi      # 0x10bf0
xorl %r8d, %r8d
xorl %r9d, %r9d
movl %edx, %ecx
movzwl (%r8,%rdi), %r11d
movl %edx, %eax
xorl %edx, %edx
divw %r11w
movb $0x20, %r10b
cmpw %cx, %r11w
ja 0x74d4
cmpw $0x1a, %ax
ja 0x74ab
orb $0x40, %al
movl %eax, %r10d
jmp 0x74d4
leal -0x1b(%rax), %ecx
cmpw $0x3, %cx
jae 0x74c2
shll $0x3, %ecx
movl $0x202e24, %r10d        # imm = 0x202E24
shrl %cl, %r10d
jmp 0x74d4
movl %eax, %ecx
addl $-0x1e, %ecx
movl %r9d, %r10d
cmpw $0x9, %cx
ja 0x74d4
leal 0x12(%rax), %r10d
movb %r10b, (%rsi)
incq %rsi
addq $0x2, %r8
movl %r10d, %r9d
cmpq $0x6, %r8
jne 0x7486
movb $0x0, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/dgnhelp.cpp
// Function: DGNAsciiToRad50(char const*, unsigned short*)
void DGNAsciiToRad50( const char *str, unsigned short *pRad50 )

{
    unsigned short rad50 = 0;
    int  i;

    for( i = 0; i < 3; i++ )
    {
        unsigned short value;

        if( i >= (int) strlen(str) )
        {
            rad50 = rad50 * 40;
            continue;
        }

        if( str[i] == '$' )
            value = 27;
        else if( str[i] == '.' )
            value = 28;
        else if( str[i] == ' ' )
            value = 29;
        else if( str[i] >= '0' && str[i] <= '9' )
            value = str[i] - '0' + 30;
        else if( str[i] >= 'a' && str[i] <= 'z' )
            value = str[i] - 'a' + 1;
        else if( str[i] >= 'A' && str[i] <= 'Z' )
            value = str[i] - 'A' + 1;
        else
            value = 0;

        rad50 = rad50 * 40 + value;
    }

    *pRad50 = rad50;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2120
cltq
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %rax, %rcx
jge 0x751f
movzbl (%r14,%rcx), %esi
cmpl $0x20, %esi
je 0x752d
cmpl $0x24, %esi
je 0x7527
cmpl $0x2e, %esi
jne 0x7533
movw $0x1c, %si
jmp 0x7568
shll $0x3, %edx
leal (%rdx,%rdx,4), %edx
jmp 0x7573
movw $0x1b, %si
jmp 0x7568
movw $0x1d, %si
jmp 0x7568
leal -0x30(%rsi), %edi
cmpb $0x9, %dil
ja 0x7544
movzwl %si, %esi
addl $-0x12, %esi
jmp 0x7568
leal -0x61(%rsi), %edi
cmpb $0x19, %dil
ja 0x7555
movzwl %si, %esi
addl $-0x60, %esi
jmp 0x7568
leal -0x41(%rsi), %edi
cmpb $0x19, %dil
ja 0x7566
movzwl %si, %esi
addl $-0x40, %esi
jmp 0x7568
xorl %esi, %esi
shll $0x3, %edx
leal (%rdx,%rdx,4), %edi
movswl %si, %edx
addl %edi, %edx
incq %rcx
cmpq $0x3, %rcx
jne 0x7500
movw %dx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/dgnhelp.cpp
// Function: DGNGetAttrLinkSize
int DGNGetAttrLinkSize( DGNHandle hDGN, DGNElemCore *psElement, 
                        int nOffset )

{
    if( psElement->attr_bytes < nOffset + 4 )
        return 0;

    /* DMRS Linkage */
    if( (psElement->attr_data[nOffset+0] == 0 
         && psElement->attr_data[nOffset+1] == 0)
        || (psElement->attr_data[nOffset+0] == 0 
            && psElement->attr_data[nOffset+1] == 0x80) )
        return 8;

    /* If low order bit of second byte is set, first byte is length */
    if( psElement->attr_data[nOffset+1] & 0x10 )
        return psElement->attr_data[nOffset+0] * 2 + 2;

    /* unknown */
    return 0;
}

// Assembly:
leal 0x4(%rdx), %ecx
xorl %eax, %eax
cmpl %ecx, 0x34(%rsi)
jl 0x862b
movq 0x38(%rsi), %rsi
movslq %edx, %rdx
movzbl (%rsi,%rdx), %ecx
testl %ecx, %ecx
je 0x8612
testb $0x10, 0x1(%rsi,%rdx)
movl $0x0, %eax
je 0x862b
leal 0x2(,%rcx,2), %eax
retq
movl $0x8, %eax
cmpb $0x0, 0x1(%rsi,%rdx)
je 0x862b
testl %ecx, %ecx
jne 0x85fe
xorl %edi, %edi
cmpb 0x1(%rsi,%rdx), %dil
jno 0x85fe
retq
// File: /workspace/github_cpp_makefile_star2_O1/rurban[P]dgnlib/dgnhelp.cpp
// Function: DGNRotationToQuaternion
void DGNRotationToQuaternion( double dfRotation, int *panQuaternion )

{
    double dfRadianRot = (dfRotation / 180.0)  * PI;

    panQuaternion[0] = (int) (cos(-dfRadianRot/2.0) * 2147483647);
    panQuaternion[1] = 0;
    panQuaternion[2] = 0;
    panQuaternion[3] = (int) (sin(-dfRadianRot/2.0) * 2147483647);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
divsd 0x85bc(%rip), %xmm0     # 0x10bf8
mulsd 0x85bc(%rip), %xmm0     # 0x10c00
mulsd 0x7fdc(%rip), %xmm0     # 0x10628
movsd %xmm0, 0x8(%rsp)
callq 0x2560
mulsd 0x85a9(%rip), %xmm0     # 0x10c08
cvttsd2si %xmm0, %eax
movl %eax, (%rbx)
movq $0x0, 0x4(%rbx)
movsd 0x8(%rsp), %xmm0
callq 0x20b0
mulsd 0x8588(%rip), %xmm0     # 0x10c08
cvttsd2si %xmm0, %eax
movl %eax, 0xc(%rbx)
addq $0x10, %rsp
popq %rbx
retq