LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/rurban[P]dgnlib/cpl_string.cpp
// Function: CSLRemoveStrings
int CSLCount(char **papszStrList)
{
    int nItems=0;

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

    return nItems;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x5f03
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x5f5d
movq %rcx, %r14
movl %edx, %r15d
xorl %r13d, %r13d
cmpq $0x0, 0x8(%rbx,%r13,8)
leaq 0x1(%r13), %r13
jne 0x5e8e
testl %r15d, %r15d
jle 0x5f5d
movl %r15d, %eax
negl %eax
addq %r13, %rax
testl %eax, %eax
jle 0x5efb
movq %rax, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movslq %esi, %rax
leaq (%rbx,%rax,8), %rbp
movl %r15d, %r12d
testq %r14, %r14
je 0x5f07
incl %r15d
movl $0x8, %esi
movq %r15, %rdi
callq 0x2d20
movq %rax, (%r14)
xorl %eax, %eax
movq (%rbp,%rax,8), %rcx
movq (%r14), %rdx
movq %rcx, (%rdx,%rax,8)
movq $0x0, (%rbp,%rax,8)
incq %rax
cmpq %rax, %r12
jne 0x5edc
jmp 0x5f22
movq %rbx, %rdi
callq 0x58b2
xorl %ebx, %ebx
jmp 0x5f5d
movq (%rbp), %rdi
callq 0x6edd
movq $0x0, (%rbp)
movl $0x0, %edi
decl %r15d
jne 0x5f0b
movl 0xc(%rsp), %ecx
cmpl %ecx, %r13d
movl %ecx, %eax
movq 0x10(%rsp), %rdx
cmovll %edx, %eax
cmpl $-0x1, %ecx
cmovel %edx, %eax
cltq
leaq (%rbx,%rax,8), %rax
movq (%rax,%r12,8), %rcx
testq %rcx, %rcx
je 0x5f56
movq %rcx, (%rax)
movq 0x8(%rax,%r12,8), %rcx
addq $0x8, %rax
jmp 0x5f43
movq $0x0, (%rax)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5982
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x58eb
movq %rdi, %rbx
testq %r14, %r14
je 0x59d5
movq (%r14), %rdi
testq %rdi, %rdi
je 0x59d5
addq $0x8, %r14
leaq 0x8(%rsp), %r15
movq $0x0, 0x8(%rsp)
movq %r15, %rsi
callq 0x59e2
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x5a93
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x6edd
movq (%r14), %rdi
addq $0x8, %r14
testq %rdi, %rdi
jne 0x599b
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rurban[P]dgnlib/cpl_string.cpp
// Function: CPLParseNameValue
const char *CPLParseNameValue(const char *pszNameValue, char **ppszKey )

{
    int  i;
    const char *pszValue;

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

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

            return pszValue;
        }
    }

    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r12
movq $-0x1, %rdi
xorl %r15d, %r15d
movzbl (%r12,%r15), %eax
testl %eax, %eax
je 0x5a83
cmpl $0x3d, %eax
je 0x5a16
cmpl $0x3a, %eax
je 0x5a16
incq %r15
decq %rdi
jmp 0x59fb
movq %rdi, %r13
negq %r13
movq %r12, %r14
subq %rdi, %r14
movzbl (%r14), %eax
cmpl $0x20, %eax
je 0x5a30
cmpl $0x9, %eax
jne 0x5a35
incq %r14
jmp 0x5a22
testq %rbx, %rbx
je 0x5a86
negl %edi
callq 0x2d6b
movq %rax, (%rbx)
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2150
movq (%rbx), %rax
movb $0x0, (%rax,%r15)
testq %r15, %r15
je 0x5a86
movq (%rbx), %rax
movzbl -0x1(%rax,%r13), %ecx
cmpl $0x20, %ecx
je 0x5a72
cmpl $0x9, %ecx
jne 0x5a86
movb $0x0, -0x1(%rax,%r13)
decq %r13
cmpq $0x1, %r13
jg 0x5a5f
jmp 0x5a86
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rurban[P]dgnlib/cpl_string.cpp
// Function: CSLSetNameValue
char **CSLSetNameValue(char **papszList, 
                       const char *pszName, const char *pszValue)
{
    char **papszPtr;
    int nLen;

    if (pszName == NULL )
        return papszList;

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

            CPLFree(*papszPtr);

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

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

    if( pszValue == NULL )
        return papszList;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
testq %rsi, %rsi
je 0x5b8c
movq %rsi, %r15
movq %rdx, (%rsp)
testq %r14, %r14
je 0x5afa
movq %r15, %rdi
callq 0x2120
movq (%r14), %r12
testq %r12, %r12
je 0x5afa
movslq %eax, %r13
movq %r14, %rbx
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x23b0
testl %eax, %eax
jne 0x5aed
movzbl (%r12,%r13), %ebp
cmpl $0x3d, %ebp
je 0x5b20
cmpl $0x3a, %ebp
je 0x5b20
movq 0x8(%rbx), %r12
addq $0x8, %rbx
testq %r12, %r12
jne 0x5acc
movq (%rsp), %rdx
testq %rdx, %rdx
je 0x5b8c
movq %r14, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x65f7
movq %r12, %rdi
callq 0x6edd
movq (%rsp), %r13
testq %r13, %r13
je 0x5b6f
movq %r15, %rdi
callq 0x2120
movq %rax, %r12
movq %r13, %rdi
callq 0x2120
leaq (%r12,%rax), %rdi
addq $0x2, %rdi
callq 0x2d6b
movq %rax, (%rbx)
leaq 0x9b66(%rip), %rsi      # 0xf6c1
movq %rax, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %r13, %r8
xorl %eax, %eax
callq 0x20a0
jmp 0x5b8c
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x5b85
movq %rax, (%rbx)
movq 0x10(%rbx), %rax
addq $0x8, %rbx
jmp 0x5b73
movq $0x0, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9873(%rip), %rsi      # 0xf420
callq 0x6dc9
testq %rax, %rax
je 0x5bfe
movq %rax, %r14
movq %rax, %rdi
callq 0x6dfd
xorl %ebx, %ebx
testl %eax, %eax
jne 0x5bed
movq %r14, %rdi
callq 0x3163
testq %rax, %rax
je 0x5be3
movq %rbx, %rdi
movq %rax, %rsi
callq 0x57e8
movq %rax, %rbx
movq %r14, %rdi
callq 0x6dfd
jmp 0x5bc4
movq %r14, %rdi
callq 0x6dce
xorl %edi, %edi
callq 0x3163
jmp 0x5c2a
callq 0x2040
movl (%rax), %edi
callq 0x20d0
leaq 0x9a7f(%rip), %rdx      # 0xf690
xorl %ebx, %ebx
movl $0x3, %edi
movl $0x4, %esi
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x460c
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5c96
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x9924(%rip), %rsi      # 0xf571
movq %rbx, %rdi
callq 0x6e04
testq %rax, %rax
je 0x5c9b
movq %rax, %r15
movq (%r12), %rdi
xorl %r14d, %r14d
testq %rdi, %rdi
je 0x5cf4
movq %r15, %rsi
callq 0x6ec4
cmpl $-0x1, %eax
je 0x5cca
movl $0xa, %edi
movq %r15, %rsi
callq 0x6ec9
cmpl $-0x1, %eax
je 0x5cca
movq 0x8(%r12,%r14,8), %rdi
incq %r14
jmp 0x5c64
xorl %r14d, %r14d
jmp 0x5cfc
callq 0x2040
movl (%rax), %edi
callq 0x20d0
leaq 0x99f2(%rip), %rdx      # 0xf6a0
xorl %r14d, %r14d
movl $0x3, %edi
movl $0x4, %esi
movq %rbx, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x460c
jmp 0x5cfc
callq 0x2040
movl (%rax), %edi
callq 0x20d0
leaq 0x99c3(%rip), %rdx      # 0xf6a0
movl $0x3, %edi
movl $0x3, %esi
movq %rbx, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x460c
movq %r15, %rdi
callq 0x6e09
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5d28
movq 0xf2a3(%rip), %rax      # 0x14fc8
movq (%rax), %r14
xorl %r15d, %r15d
testq %rbx, %rbx
je 0x5d5c
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x5d5c
leaq 0x984f(%rip), %r12      # 0xf58e
xorl %r15d, %r15d
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x6e3b
movq 0x8(%rbx,%r15,8), %rdx
incq %r15
testq %rdx, %rdx
jne 0x5d42
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rurban[P]dgnlib/cpl_string.cpp
// Function: CSLInsertStrings
char **CSLInsertStrings(char **papszStrList, int nInsertAtLineNo, 
                        char **papszNewLines)
{
    int     i, nSrcLines, nDstLines, nToInsert;
    char    **ppszSrc, **ppszDst;

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

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

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

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

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
testq %rdx, %rdx
je 0x5e36
movq %rdx, %r14
cmpq $0x0, (%rdx)
je 0x5e36
movl %esi, %ebp
xorl %eax, %eax
cmpq $0x0, 0x8(%r14,%rax,8)
leaq 0x1(%rax), %rax
jne 0x5d90
xorl %r15d, %r15d
testq %rbx, %rbx
je 0x5db9
cmpq $0x0, (%rbx)
je 0x5db9
xorl %r15d, %r15d
cmpq $0x0, 0x8(%rbx,%r15,8)
leaq 0x1(%r15), %r15
jne 0x5dad
movl %r15d, %r12d
addq %rax, %r12
leal 0x1(%r12), %eax
movslq %eax, %rsi
shlq $0x3, %rsi
movq %rbx, %rdi
callq 0x2dcb
movq %rax, %rbx
movslq %r15d, %rcx
cmpl %ebp, %ecx
movl %ebp, %eax
cmovll %ecx, %eax
leaq (%rbx,%rcx,8), %rdx
cmpl $-0x1, %ebp
cmovel %ecx, %eax
movq $0x0, (%rdx)
movslq %r12d, %rsi
leaq (%rbx,%rsi,8), %rsi
incl %ecx
movq (%rdx), %rdi
movq %rdi, (%rsi)
addq $-0x8, %rsi
addq $-0x8, %rdx
decl %ecx
cmpl %eax, %ecx
jg 0x5dfa
movq (%r14), %rdi
testq %rdi, %rdi
je 0x5e36
cltq
leaq (%rbx,%rax,8), %r15
xorl %r12d, %r12d
callq 0x2e41
movq %rax, (%r15,%r12)
movq 0x8(%r14,%r12), %rdi
addq $0x8, %r12
testq %rdi, %rdi
jne 0x5e1f
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5fb0
movq %rdi, %r15
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x5fb0
movq %rsi, %r14
xorl %r12d, %r12d
movq %r14, %rsi
callq 0x22e0
testl %eax, %eax
je 0x5fad
movq 0x8(%r15,%r12,8), %rdi
incq %r12
testq %rdi, %rdi
jne 0x5f92
jmp 0x5fb0
movl %r12d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x62fd
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 0x228fc(%rip), %rax     # 0x28c20
imulq $0x1f40, %rax, %rdi     # imm = 0x1F40
leaq 0xf06e(%rip), %rbx      # 0x153a0
addq %rbx, %rdi
movl $0x1f3f, %esi           # imm = 0x1F3F
movq %r10, %rdx
callq 0x2190
movslq 0x228d7(%rip), %rax     # 0x28c20
leal 0x1(%rax), %ecx
xorl %edx, %edx
cmpl $0xa, %ecx
cmovnel %ecx, %edx
movl %edx, 0x228c6(%rip)     # 0x28c20
imulq $0x1f40, %rax, %rax     # imm = 0x1F40
addq %rbx, %rax
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x63cd
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 0x2282c(%rip), %rax     # 0x28c20
imulq $0x1f40, %rax, %rdi     # imm = 0x1F40
leaq 0xef9e(%rip), %r14      # 0x153a0
addq %r14, %rdi
movl $0x1f3f, %esi           # imm = 0x1F3F
movq %r10, %rdx
callq 0x2190
movslq 0x22807(%rip), %rax     # 0x28c20
leal 0x1(%rax), %ecx
xorl %edx, %edx
cmpl $0xa, %ecx
cmovnel %ecx, %edx
movl %edx, 0x227f6(%rip)     # 0x28c20
imulq $0x1f40, %rax, %rsi     # imm = 0x1F40
addq %r14, %rsi
movq %rbx, %rdi
callq 0x57e8
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x925b(%rip), %rsi      # 0xf6b0
callq 0x22e0
xorl %ebx, %ebx
testl %eax, %eax
je 0x649c
leaq 0x924c(%rip), %rsi      # 0xf6b3
movq %r14, %rdi
callq 0x22e0
testl %eax, %eax
je 0x649c
leaq 0x9118(%rip), %rsi      # 0xf592
movq %r14, %rdi
callq 0x22e0
testl %eax, %eax
je 0x649c
leaq 0x922c(%rip), %rsi      # 0xf6b9
movq %r14, %rdi
callq 0x22e0
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_O3/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 0x5f6f
movl %eax, %ecx
movl $0x1, %eax
cmpl $-0x1, %ecx
je 0x64ca
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
callq 0x64e9
movq %rax, %rdi
movl %ebx, %eax
testq %rdi, %rdi
je 0x64c4
popq %rbx
popq %r14
popq %r15
jmp 0x6447
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6551
movq %rdi, %r14
movq (%rdi), %r12
testq %r12, %r12
je 0x6551
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 0x23b0
testl %eax, %eax
jne 0x6543
movzbl (%r12,%r13), %eax
cmpl $0x3d, %eax
je 0x6561
cmpl $0x3a, %eax
je 0x6561
movq (%r14), %r12
addq $0x8, %r14
testq %r12, %r12
jne 0x6522
jmp 0x6554
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq (%r12,%r13), %r15
incq %r15
jmp 0x6554
// File: /workspace/github_cpp_makefile_star2_O3/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 0x65e7
movq %rdi, %r14
movq (%rdi), %r13
testq %r13, %r13
je 0x65e7
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 0x23b0
testl %eax, %eax
jne 0x65d9
movzbl (%r13,%r12), %eax
cmpl $0x3d, %eax
je 0x65c5
cmpl $0x3a, %eax
jne 0x65d9
addq %r12, %r13
incq %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x57e8
movq %rax, %r15
movq (%r14), %r13
addq $0x8, %r14
testq %r13, %r13
jne 0x65a3
jmp 0x65ea
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6668
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 0x2d6b
movq %rax, %r12
leaq 0x9079(%rip), %rsi      # 0xf6bb
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x20a0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x57e8
movq %rax, %rbx
movq %r12, %rdi
callq 0x6edd
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x6742
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0x6734
movq %rsi, %rbx
xorl %r15d, %r15d
cmpq $0x0, 0x8(%r14,%r15,8)
leaq 0x1(%r15), %r15
jne 0x669e
movq $0x0, (%rsp)
movq (%r14), %rdi
movq %rsp, %rsi
callq 0x59e2
movq %rax, %r12
movq %rax, %rdi
callq 0x2120
movq %rax, %r13
movq (%rsp), %rdi
callq 0x2120
movq %rax, %rbp
movq %rbx, %rdi
callq 0x2120
addq %r13, %rbp
leaq (%rax,%rbp), %rdi
incq %rdi
callq 0x2d6b
movq %rax, %r13
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x22a0
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2510
movq %r13, %rdi
movq %r12, %rsi
callq 0x2510
movq (%r14), %rdi
callq 0x6edd
movq %r13, (%r14)
movq (%rsp), %rdi
callq 0x6edd
addq $0x8, %r14
decq %r15
jne 0x66aa
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2d6b
movb $0x0, (%rax,%r14,2)
testl %r14d, %r14d
jle 0x6cfe
movl %ebp, %ecx
xorl %edx, %edx
leaq 0x8a99(%rip), %rsi      # 0xf770
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 0x6cd7
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2d6b
movb (%r14), %dl
xorl %ecx, %ecx
testb %dl, %dl
je 0x6d9f
leal -0x30(%rdx), %esi
cmpb $0xa, %sil
jb 0x6d54
leal -0x41(%rdx), %esi
cmpb $0x5, %sil
ja 0x6d46
addb $-0x37, %dl
jmp 0x6d52
leal -0x61(%rdx), %esi
cmpb $0x5, %sil
ja 0x6d9f
addb $-0x57, %dl
movl %edx, %esi
shlb $0x4, %sil
movb %sil, (%rax,%rcx)
movb 0x1(%r14,%rcx,2), %dl
leal -0x30(%rdx), %edi
cmpb $0x9, %dil
ja 0x6d6f
orb %sil, %dil
jmp 0x6d91
leal -0x41(%rdx), %edi
cmpb $0x5, %dil
ja 0x6d80
addb %sil, %dl
addb $-0x37, %dl
jmp 0x6d8f
leal -0x61(%rdx), %edi
cmpb $0x5, %dil
ja 0x6d9f
addb %sil, %dl
addb $-0x57, %dl
movl %edx, %edi
movb %dil, (%rax,%rcx)
movb 0x2(%r14,%rcx,2), %dl
incq %rcx
jmp 0x6d2b
movl %ecx, %edx
movb $0x0, (%rax,%rdx)
movl %ecx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0xc(%rsp), %rbx
movq %rbx, (%rsp)
xorl %r12d, %r12d
leaq 0x8(%rsp), %rcx
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x7209
testq %rax, %rax
je 0x71f7
cmpl $0x41, 0x8(%rsp)
jne 0x71aa
cmpl $0x6, 0xc(%rsp)
jg 0x71e6
movl $0x1, %ebp
leaq 0x8(%rsp), %r13
movq %rbx, (%rsp)
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %r13, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x7209
testq %rax, %rax
je 0x71f7
incl %ebp
cmpl $0x41, 0x8(%rsp)
jne 0x71b4
cmpl $0x7, 0xc(%rsp)
jl 0x71b4
movzbl 0x8(%rax), %eax
movq 0x10(%rsp), %rcx
movl %eax, (%rcx)
movl $0x1, %r12d
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_O3/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
leaq 0x14(%rsp), %r13
movq %r13, (%rsp)
leaq 0x10(%rsp), %rcx
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x7209
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x7362
cmpl $0x7d2f, 0x10(%rsp)     # imm = 0x7D2F
jne 0x7320
cmpl $0x7, 0x14(%rsp)
jg 0x735f
movl $0x1, %r15d
leaq 0x10(%rsp), %r12
movq %r13, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
movq %r12, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x7209
testq %rax, %rax
je 0x7362
incl %r15d
cmpl $0x7d2f, 0x10(%rsp)     # imm = 0x7D2F
jne 0x732b
cmpl $0x8, 0x14(%rsp)
jl 0x732b
movl 0x4(%rax), %ebp
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_O3/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 0x8894(%rip), %rdi      # 0xfc10
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 0x73d0
cmpw $0x1a, %ax
ja 0x73a7
orb $0x40, %al
movl %eax, %r10d
jmp 0x73d0
leal -0x1b(%rax), %ecx
cmpw $0x3, %cx
jae 0x73be
shll $0x3, %ecx
movl $0x202e24, %r10d        # imm = 0x202E24
shrl %cl, %r10d
jmp 0x73d0
movl %eax, %ecx
addl $-0x1e, %ecx
movl %r9d, %r10d
cmpw $0x9, %cx
ja 0x73d0
leal 0x12(%rax), %r10d
movb %r10b, (%rsi)
incq %rsi
addq $0x2, %r8
movl %r10d, %r9d
cmpq $0x6, %r8
jne 0x7382
movb $0x0, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x741b
movzbl (%r14,%rcx), %esi
cmpl $0x20, %esi
je 0x7429
cmpl $0x24, %esi
je 0x7423
cmpl $0x2e, %esi
jne 0x742f
movw $0x1c, %si
jmp 0x7464
shll $0x3, %edx
leal (%rdx,%rdx,4), %edx
jmp 0x746f
movw $0x1b, %si
jmp 0x7464
movw $0x1d, %si
jmp 0x7464
leal -0x30(%rsi), %edi
cmpb $0x9, %dil
ja 0x7440
movzwl %si, %esi
addl $-0x12, %esi
jmp 0x7464
leal -0x61(%rsi), %edi
cmpb $0x19, %dil
ja 0x7451
movzwl %si, %esi
addl $-0x60, %esi
jmp 0x7464
leal -0x41(%rsi), %edi
cmpb $0x19, %dil
ja 0x7462
movzwl %si, %esi
addl $-0x40, %esi
jmp 0x7464
xorl %esi, %esi
shll $0x3, %edx
leal (%rdx,%rdx,4), %edi
movswl %si, %edx
addl %edi, %edx
incq %rcx
cmpq $0x3, %rcx
jne 0x73fc
movw %dx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7720(%rip), %xmm0     # 0xfc18
mulsd 0x7720(%rip), %xmm0     # 0xfc20
mulsd 0x7140(%rip), %xmm0     # 0xf648
movsd %xmm0, 0x8(%rsp)
callq 0x2550
mulsd 0x770d(%rip), %xmm0     # 0xfc28
cvttsd2si %xmm0, %eax
movl %eax, (%rbx)
movq $0x0, 0x4(%rbx)
movsd 0x8(%rsp), %xmm0
callq 0x20b0
mulsd 0x76ec(%rip), %xmm0     # 0xfc28
cvttsd2si %xmm0, %eax
movl %eax, 0xc(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/rurban[P]dgnlib/dgnhelp.cpp
// Function: DGNQuaternionToMatrix
void DGNQuaternionToMatrix( int *quat, float *mat )
{
  double q[4];

  q[0] = 1.0 * quat[1] / (1<<31);
  q[1] = 1.0 * quat[2] / (1<<31);
  q[2] = 1.0 * quat[3] / (1<<31);
  q[3] = 1.0 * quat[0] / (1<<31);

  mat[0*3+0] = (float) (q[0]*q[0] - q[1]*q[1] - q[2]*q[2] + q[3]*q[3]);
  mat[0*3+1] = (float) (2 * (q[2]*q[3] + q[0]*q[1]));
  mat[0*3+2] = (float) (2 * (q[0]*q[2] - q[1]*q[3]));
  mat[1*3+0] = (float) (2 * (q[0]*q[1] - q[2]*q[3]));
  mat[1*3+1] = (float) (-q[0]*q[0] + q[1]*q[1] - q[2]*q[2] + q[3]*q[3]);
  mat[1*3+2] = (float) (2 * (q[0]*q[3] + q[1]*q[2]));
  mat[2*3+0] = (float) (2 * (q[0]*q[2] + q[1]*q[3])); 
  mat[2*3+1] = (float) (2 * (q[1]*q[2] - q[0]*q[3]));
  mat[2*3+2] = (float) (-q[0]*q[0] - q[1]*q[1] + q[2]*q[2] + q[3]*q[3]);
}

// Assembly:
cvtsi2sdl 0x4(%rdi), %xmm0
movsd 0x76da(%rip), %xmm1     # 0xfc30
cvtsi2sdl (%rdi), %xmm2
mulsd %xmm1, %xmm0
cvtdq2pd 0x8(%rdi), %xmm7
mulsd %xmm1, %xmm2
mulpd 0x76d1(%rip), %xmm7     # 0xfc40
movapd %xmm0, %xmm3
movapd %xmm7, %xmm1
movapd 0x6cd1(%rip), %xmm5     # 0xf250
movapd %xmm0, %xmm9
mulsd %xmm7, %xmm9
movapd %xmm0, %xmm6
unpcklpd %xmm0, %xmm6            # xmm6 = xmm6[0],xmm0[0]
movapd %xmm0, %xmm4
xorpd %xmm5, %xmm4
movapd %xmm7, %xmm8
unpcklpd %xmm4, %xmm8            # xmm8 = xmm8[0],xmm4[0]
mulsd %xmm0, %xmm4
movapd %xmm7, %xmm10
movapd %xmm0, %xmm11
mulpd %xmm7, %xmm6
unpcklpd %xmm7, %xmm0            # xmm0 = xmm0[0],xmm7[0]
mulsd %xmm7, %xmm7
mulsd %xmm3, %xmm3
subsd %xmm7, %xmm3
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
movapd %xmm1, %xmm12
xorpd %xmm5, %xmm12
movapd %xmm2, %xmm13
mulsd %xmm12, %xmm13
mulsd %xmm1, %xmm12
addsd %xmm12, %xmm3
movapd %xmm1, %xmm14
mulsd %xmm2, %xmm14
addsd %xmm9, %xmm14
movapd %xmm2, %xmm9
mulsd %xmm2, %xmm9
addsd %xmm9, %xmm3
addsd %xmm14, %xmm14
unpcklpd %xmm14, %xmm3           # xmm3 = xmm3[0],xmm14[0]
movapd %xmm4, %xmm14
addsd %xmm7, %xmm14
addsd %xmm12, %xmm14
addsd %xmm9, %xmm14
mulsd %xmm1, %xmm10
mulsd %xmm2, %xmm11
addsd %xmm10, %xmm11
addsd %xmm11, %xmm11
unpcklpd %xmm11, %xmm14          # xmm14 = xmm14[0],xmm11[0]
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
mulpd %xmm8, %xmm2
xorpd %xmm2, %xmm5
unpcklpd %xmm5, %xmm13           # xmm13 = xmm13[0],xmm5[0]
addpd %xmm13, %xmm6
addpd %xmm6, %xmm6
shufpd $0x1, %xmm6, %xmm6      # xmm6 = xmm6[1,0]
cvtpd2ps %xmm3, %xmm3
cvtpd2ps %xmm6, %xmm5
unpcklpd %xmm5, %xmm3            # xmm3 = xmm3[0],xmm5[0]
movupd %xmm3, (%rsi)
mulpd %xmm1, %xmm0
addpd %xmm2, %xmm0
cvtpd2ps %xmm14, %xmm2
addpd %xmm0, %xmm0
cvtpd2ps %xmm0, %xmm0
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
movupd %xmm2, 0x10(%rsi)
subsd %xmm7, %xmm4
mulsd %xmm1, %xmm1
addsd %xmm4, %xmm1
addsd %xmm9, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss %xmm0, 0x20(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/rurban[P]dgnlib/dgnread.cpp
// Function: DGNGotoElement
int DGNGotoElement( DGNHandle hDGN, int element_id )

{
    DGNInfo     *psDGN = (DGNInfo *) hDGN;

    DGNBuildIndex( psDGN );

    if( element_id < 0 || element_id >= psDGN->element_count )
        return FALSE;

    if( VSIFSeek( psDGN->fp, psDGN->element_index[element_id].offset, 
                  SEEK_SET ) != 0 )
        return FALSE;

    psDGN->next_element_id = element_id;
    psDGN->in_complex_group = FALSE;

    return TRUE;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x8707
xorl %r14d, %r14d
testl %ebp, %ebp
js 0x86ff
cmpl %ebp, 0x20044(%rbx)
jle 0x86ff
movq (%rbx), %rdi
movq 0x20050(%rbx), %rax
movl %ebp, %ecx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %rsi
xorl %r14d, %r14d
xorl %edx, %edx
callq 0x6e0e
testl %eax, %eax
jne 0x86ff
movl %ebp, 0x8(%rbx)
movl $0x0, 0x20384(%rbx)
movl $0x1, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/rurban[P]dgnlib/dgnread.cpp
// Function: DGNLoadRawElement(DGNInfo*, int*, int*)
int DGNLoadRawElement( DGNInfo *psDGN, int *pnType, int *pnLevel )

{
/* -------------------------------------------------------------------- */
/*      Read the first four bytes to get the level, type, and word      */
/*      count.                                                          */
/* -------------------------------------------------------------------- */
    int         nType, nWords, nLevel;

    if( VSIFRead( psDGN->abyElem, 1, 4, psDGN->fp ) != 4 )
        return FALSE;

    /* Is this an 0xFFFF endof file marker? */
    if( psDGN->abyElem[0] == 0xff && psDGN->abyElem[1] == 0xff )
        return FALSE;

    nWords = psDGN->abyElem[2] + psDGN->abyElem[3]*256;
    nType = psDGN->abyElem[1] & 0x7f;
    nLevel = psDGN->abyElem[0] & 0x3f;

/* -------------------------------------------------------------------- */
/*      Read the rest of the element data into the working buffer.      */
/* -------------------------------------------------------------------- */
    CPLAssert( nWords * 2 + 4 <= (int) sizeof(psDGN->abyElem) );

    if( (int) VSIFRead( psDGN->abyElem + 4, 2, nWords, psDGN->fp ) != nWords )
        return FALSE;

    psDGN->nElemBytes = nWords * 2 + 4;

    psDGN->next_element_id++;

/* -------------------------------------------------------------------- */
/*      Return requested info.                                          */
/* -------------------------------------------------------------------- */
    if( pnType != NULL )
        *pnType = nType;
    
    if( pnLevel != NULL )
        *pnLevel = nLevel;
    
    return TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
addq $0x10, %rdi
movq (%r15), %rcx
movl $0x1, %esi
movl $0x4, %edx
callq 0x6e1d
xorl %ebp, %ebp
cmpq $0x4, %rax
jne 0x8afc
movzbl 0x10(%r15), %r13d
movb 0x11(%r15), %bl
movl %r13d, %eax
andb %bl, %al
cmpb $-0x1, %al
je 0x8afc
movq %r12, (%rsp)
movzwl 0x12(%r15), %r12d
leaq 0x14(%r15), %rdi
movq (%r15), %rcx
movl $0x2, %esi
movq %r12, %rdx
callq 0x6e1d
cmpl %eax, %r12d
jne 0x8afc
leal 0x4(,%r12,2), %eax
movl %eax, 0xc(%r15)
incl 0x8(%r15)
testq %r14, %r14
je 0x8ae7
movzbl %bl, %eax
andl $0x7f, %eax
movl %eax, (%r14)
movl $0x1, %ebp
movq (%rsp), %rax
testq %rax, %rax
je 0x8afc
andl $0x3f, %r13d
movl %r13d, (%rax)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/rurban[P]dgnlib/dgnread.cpp
// Function: DGNFreeElement
void DGNFreeElement( DGNHandle hDGN, DGNElemCore *psElement )

{
    if( psElement->attr_data != NULL )
        VSIFree( psElement->attr_data );

    if( psElement->raw_data != NULL )
        VSIFree( psElement->raw_data );

    if( psElement->stype == DGNST_TAG_SET )
    {
        int             iTag;

        DGNElemTagSet *psTagSet = (DGNElemTagSet *) psElement;
        CPLFree( psTagSet->tagSetName );

        for( iTag = 0; iTag < psTagSet->tagCount; iTag++ )
        {
            CPLFree( psTagSet->tagList[iTag].name );
            CPLFree( psTagSet->tagList[iTag].prompt );

            if( psTagSet->tagList[iTag].type == 1 )
                CPLFree( psTagSet->tagList[iTag].defaultValue.string );
        }
        CPLFree( psTagSet->tagList );
    }
    else if( psElement->stype == DGNST_TAG_VALUE )
    {
        if( ((DGNElemTagValue *) psElement)->tagType == 1 )
            CPLFree( ((DGNElemTagValue *) psElement)->tagValue.string );
    }

    CPLFree( psElement );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x38(%rsi), %rdi
testq %rdi, %rdi
je 0xac2a
callq 0x6edd
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0xac38
callq 0x6edd
movl 0xc(%rbx), %eax
cmpl $0x9, %eax
je 0xaca3
cmpl $0xa, %eax
jne 0xacb8
movq 0x60(%rbx), %rdi
callq 0x6edd
movl $0x68, %r14d
cmpl $0x0, 0x50(%rbx)
jle 0xacaf
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x68(%rbx), %rax
movq (%rax,%r15), %rdi
callq 0x6edd
movq 0x68(%rbx), %rax
movq 0x10(%rax,%r15), %rdi
callq 0x6edd
movq 0x68(%rbx), %rax
cmpl $0x1, 0x18(%rax,%r15)
jne 0xac91
movq 0x20(%rax,%r15), %rdi
callq 0x6edd
incq %r12
movslq 0x50(%rbx), %rax
addq $0x28, %r15
cmpq %rax, %r12
jl 0xac60
jmp 0xacaf
movl $0x60, %r14d
cmpl $0x1, 0x50(%rbx)
jne 0xacb8
movq (%rbx,%r14), %rdi
callq 0x6edd
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6edd
// File: /workspace/github_cpp_makefile_star2_O3/rurban[P]dgnlib/dgnread.cpp
// Function: DGNInverseTransformPoint(DGNInfo*, DGNPoint*)
void DGNInverseTransformPoint( DGNInfo *psDGN, DGNPoint *psPoint )

{
    psPoint->x = (psPoint->x + psDGN->origin_x) / psDGN->scale;
    psPoint->y = (psPoint->y + psDGN->origin_y) / psDGN->scale;
    psPoint->z = (psPoint->z + psDGN->origin_z) / psDGN->scale;

    psPoint->x = MAX(-2147483647,MIN(2147483647,psPoint->x));
    psPoint->y = MAX(-2147483647,MIN(2147483647,psPoint->y));
    psPoint->z = MAX(-2147483647,MIN(2147483647,psPoint->z));
}

// Assembly:
movsd 0x10(%rsi), %xmm0
addsd 0x20038(%rdi), %xmm0
movsd 0x20020(%rdi), %xmm1
divsd %xmm1, %xmm0
movupd (%rsi), %xmm2
movupd 0x20028(%rdi), %xmm3
addpd %xmm2, %xmm3
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
divpd %xmm1, %xmm3
movapd 0x5a03(%rip), %xmm1     # 0x10720
movapd %xmm1, %xmm2
cmpnltpd %xmm3, %xmm2
movapd 0x5a02(%rip), %xmm4     # 0x10730
movapd %xmm3, %xmm5
cmpltpd %xmm4, %xmm5
andpd %xmm5, %xmm2
andpd %xmm2, %xmm4
andnpd %xmm1, %xmm2
cmpltpd %xmm3, %xmm1
orpd %xmm1, %xmm5
orpd %xmm4, %xmm2
andpd %xmm5, %xmm2
andnpd %xmm3, %xmm5
orpd %xmm2, %xmm5
movupd %xmm5, (%rsi)
movsd 0x4ec0(%rip), %xmm3     # 0xfc28
ucomisd %xmm3, %xmm0
movapd %xmm3, %xmm4
cmpltsd %xmm0, %xmm4
movapd %xmm4, %xmm1
andpd %xmm3, %xmm1
movsd 0x5943(%rip), %xmm2     # 0x106c8
andnpd %xmm2, %xmm4
orpd %xmm1, %xmm4
movapd %xmm0, %xmm1
cmpltsd %xmm2, %xmm1
andpd %xmm1, %xmm4
andnpd %xmm3, %xmm1
orpd %xmm4, %xmm1
movapd %xmm1, %xmm3
ja 0xadac
movapd %xmm0, %xmm3
ucomisd %xmm0, %xmm2
ja 0xadb6
movapd %xmm3, %xmm1
movsd %xmm1, 0x10(%rsi)
retq