LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7ef0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7f3c
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x7f35
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x2300
cmpl $0x0, %eax
jne 0x7f28
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7f3c
jmp 0x7f2a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7ef7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rurban[P]dgnlib/cpl_string.cpp
// Function: CSLTokenizeStringComplex
char ** CSLTokenizeStringComplex( const char * pszString,
                                  const char * pszDelimiters,
                                  int bHonourStrings, int bAllowEmptyTokens )

{
    int         nFlags = 0;

    if( bHonourStrings )
        nFlags |= CSLT_HONOURSTRINGS;
    if( bAllowEmptyTokens )
        nFlags |= CSLT_ALLOWEMPTYTOKENS;

    return CSLTokenizeString2( pszString, pszDelimiters, nFlags );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x830c
movl -0x1c(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x831b
movl -0x1c(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x7f80
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x8378
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movslq 0x2ab56(%rip), %rax     # 0x32f20
leaq 0x172cf(%rip), %rdi     # 0x1f6a0
imulq $0x1f40, %rax, %rax     # imm = 0x1F40
addq %rax, %rdi
movq -0x8(%rbp), %rdx
leaq -0x20(%rbp), %rcx
movl $0x1f3f, %esi           # imm = 0x1F3F
callq 0x21a0
leaq -0x20(%rbp), %rax
movl 0x2ab29(%rip), %eax     # 0x32f20
movl %eax, -0x24(%rbp)
movl 0x2ab20(%rip), %eax     # 0x32f20
addl $0x1, %eax
movl %eax, 0x2ab17(%rip)     # 0x32f20
cmpl $0xa, %eax
jne 0x8418
movl $0x0, 0x2ab08(%rip)     # 0x32f20
movslq -0x24(%rbp), %rax
imulq $0x1f40, %rax, %rcx     # imm = 0x1F40
leaq 0x17276(%rip), %rax     # 0x1f6a0
addq %rcx, %rax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x847b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movslq 0x2aa56(%rip), %rax     # 0x32f20
leaq 0x171cf(%rip), %rdi     # 0x1f6a0
imulq $0x1f40, %rax, %rax     # imm = 0x1F40
addq %rax, %rdi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movl $0x1f3f, %esi           # imm = 0x1F3F
callq 0x21a0
leaq -0x30(%rbp), %rax
movl 0x2aa29(%rip), %eax     # 0x32f20
movl %eax, -0x34(%rbp)
movl 0x2aa20(%rip), %eax     # 0x32f20
addl $0x1, %eax
movl %eax, 0x2aa17(%rip)     # 0x32f20
cmpl $0xa, %eax
jne 0x8518
movl $0x0, 0x2aa08(%rip)     # 0x32f20
movq -0x8(%rbp), %rdi
movslq -0x34(%rbp), %rax
imulq $0x1f40, %rax, %rax     # imm = 0x1F40
leaq 0x17172(%rip), %rsi     # 0x1f6a0
addq %rax, %rsi
callq 0x72e0
addq $0xf0, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x11140(%rip), %rsi     # 0x19697
callq 0x2300
cmpl $0x0, %eax
je 0x85a0
movq -0x10(%rbp), %rdi
leaq 0x1112e(%rip), %rsi     # 0x1969a
callq 0x2300
cmpl $0x0, %eax
je 0x85a0
movq -0x10(%rbp), %rdi
leaq 0x11011(%rip), %rsi     # 0x19592
callq 0x2300
cmpl $0x0, %eax
je 0x85a0
movq -0x10(%rbp), %rdi
leaq 0x1110a(%rip), %rsi     # 0x196a0
callq 0x2300
cmpl $0x0, %eax
jne 0x85a9
movl $0x0, -0x4(%rbp)
jmp 0x85b0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7ed0
cmpl $-0x1, %eax
je 0x85ee
movl $0x1, -0x4(%rbp)
jmp 0x861a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8630
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x860e
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x861a
movq -0x28(%rbp), %rdi
callq 0x8540
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x864e
cmpq $0x0, -0x18(%rbp)
jne 0x865b
movq $0x0, -0x8(%rbp)
jmp 0x86e0
movq -0x18(%rbp), %rdi
callq 0x2120
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x86d8
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x23c0
cmpl $0x0, %eax
jne 0x86ca
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3d, %eax
je 0x86b2
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
jne 0x86ca
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x86e0
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x8667
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8716
cmpq $0x0, -0x18(%rbp)
jne 0x8723
movq $0x0, -0x8(%rbp)
jmp 0x87af
movq -0x18(%rbp), %rdi
callq 0x2120
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x87a7
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x23c0
cmpl $0x0, %eax
jne 0x8799
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3d, %eax
je 0x877a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
jne 0x8799
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movslq -0x1c(%rbp), %rax
addq %rax, %rsi
addq $0x1, %rsi
callq 0x72e0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x872f
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x87e2
cmpq $0x0, -0x20(%rbp)
jne 0x87ec
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8852
movq -0x18(%rbp), %rdi
callq 0x2120
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2120
movq -0x30(%rbp), %rdi
addq %rax, %rdi
addq $0x2, %rdi
callq 0x3040
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x10e79(%rip), %rsi     # 0x196a2
movb $0x0, %al
callq 0x20a0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x72e0
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa000
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7390
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8950
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq -0x20(%rbp), %rsi
callq 0x7600
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2120
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2120
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2120
movq -0x38(%rbp), %rdi
addq %rax, %rdi
addq $0x1, %rdi
callq 0x3040
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x22c0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2500
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2500
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xa000
movq -0x30(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rdi
callq 0xa000
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8883
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
shll %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x3040
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl -0x4(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x97b3
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0xf, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0xf0, %eax
sarl $0x4, %eax
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rcx
leaq 0xffda(%rip), %rax      # 0x19750
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movslq -0x20(%rbp), %rcx
leaq 0xffbd(%rip), %rax      # 0x19750
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x973a
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: rurban[P]dgnlib/cpl_vsisimple.cpp
// Function: VSITime
unsigned long VSITime( unsigned long * pnTimeToSet )

{
    time_t tTime;
        
    tTime = time( NULL );

    if( pnTimeToSet != NULL )
        *pnTimeToSet = (unsigned long) tTime;

    return (unsigned long) tTime;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x22a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa0ab
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rurban[P]dgnlib/dgnhelp.cpp
// Function: DGNLookupColor
int DGNLookupColor( DGNHandle hDGN, int color_index, 
                    int * red, int * green, int * blue )

{
    DGNInfo     *psDGN = (DGNInfo *) hDGN;

    if( color_index < 0 || color_index > 255  )
        return FALSE;

    if( !psDGN->got_color_table )
    {
        *red = abyDefaultPCT[color_index][0];
        *green = abyDefaultPCT[color_index][1];
        *blue = abyDefaultPCT[color_index][2];
    }
    else
    {
        *red = psDGN->color_table[color_index][0];
        *green = psDGN->color_table[color_index][1];
        *blue = psDGN->color_table[color_index][2];
    }

    return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0xa58e
cmpl $0xff, -0x14(%rbp)
jle 0xa59a
movl $0x0, -0x4(%rbp)
jmp 0xa65f
movq -0x38(%rbp), %rax
cmpl $0x0, 0x20058(%rax)
jne 0xa5fc
movslq -0x14(%rbp), %rcx
leaq 0x14d2e(%rip), %rax     # 0x1f2e0
imulq $0x3, %rcx, %rcx
addq %rcx, %rax
movzbl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movslq -0x14(%rbp), %rcx
leaq 0x14d13(%rip), %rax     # 0x1f2e0
imulq $0x3, %rcx, %rcx
addq %rcx, %rax
movzbl 0x1(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movslq -0x14(%rbp), %rcx
leaq 0x14cf7(%rip), %rax     # 0x1f2e0
imulq $0x3, %rcx, %rcx
addq %rcx, %rax
movzbl 0x2(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
jmp 0xa658
movq -0x38(%rbp), %rax
addq $0x2005c, %rax          # imm = 0x2005C
movslq -0x14(%rbp), %rcx
imulq $0x3, %rcx, %rcx
addq %rcx, %rax
movzbl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
addq $0x2005c, %rax          # imm = 0x2005C
movslq -0x14(%rbp), %rcx
imulq $0x3, %rcx, %rcx
addq %rcx, %rax
movzbl 0x1(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
addq $0x2005c, %rax          # imm = 0x2005C
movslq -0x14(%rbp), %rcx
imulq $0x3, %rcx, %rcx
addq %rcx, %rax
movzbl 0x2(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0xa693
jmp 0xa6fb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
leaq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r9d
leaq -0x2c(%rbp), %rax
movq %r9, %r8
movq %rax, (%rsp)
callq 0xa710
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xa6cb
movl $0x0, -0x4(%rbp)
jmp 0xa6fd
cmpl $0x41, -0x28(%rbp)
jne 0xa6ee
cmpl $0x7, -0x2c(%rbp)
jl 0xa6ee
movq -0x38(%rbp), %rax
movzbl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xa6fd
jmp 0xa6f0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa68b
ud2
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0xa9e2
jmp 0xaa76
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq -0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r9d
leaq -0x24(%rbp), %rax
movq %r9, %r8
movq %rax, (%rsp)
callq 0xa710
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xaa1a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xaa78
cmpl $0x7d2f, -0x20(%rbp)    # imm = 0x7D2F
jne 0xaa66
cmpl $0x8, -0x24(%rbp)
jl 0xaa66
movq -0x30(%rbp), %rax
movzbl 0x4(%rax), %eax
movq -0x30(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movq -0x30(%rbp), %rcx
movzbl 0x6(%rcx), %ecx
shll $0x8, %ecx
shll $0x8, %ecx
addl %ecx, %eax
movq -0x30(%rbp), %rcx
movzbl 0x7(%rcx), %ecx
shll $0x8, %ecx
shll $0x8, %ecx
shll $0x8, %ecx
addl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xaa78
jmp 0xaa68
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa9d7
ud2
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x13(%rbp)
movl 0xee07(%rip), %eax      # 0x198b0
movl %eax, -0x1a(%rbp)
movw 0xee01(%rip), %ax       # 0x198b4
movw %ax, -0x16(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x3, -0x20(%rbp)
jge 0xaba7
movw -0x2(%rbp), %ax
movw %ax, -0x12(%rbp)
movslq -0x20(%rbp), %rax
movzwl -0x1a(%rbp,%rax,2), %ecx
movzwl -0x12(%rbp), %eax
cltd
idivl %ecx
movw %ax, -0x12(%rbp)
movzwl -0x12(%rbp), %eax
cmpl $0x0, %eax
jne 0xaaf3
movb $0x20, -0x13(%rbp)
jmp 0xab6a
movzwl -0x12(%rbp), %eax
cmpl $0x1, %eax
jl 0xab14
movzwl -0x12(%rbp), %eax
cmpl $0x1a, %eax
jg 0xab14
movzwl -0x12(%rbp), %eax
subl $0x1, %eax
addl $0x41, %eax
movb %al, -0x13(%rbp)
jmp 0xab68
movzwl -0x12(%rbp), %eax
cmpl $0x1b, %eax
jne 0xab23
movb $0x24, -0x13(%rbp)
jmp 0xab66
movzwl -0x12(%rbp), %eax
cmpl $0x1c, %eax
jne 0xab32
movb $0x2e, -0x13(%rbp)
jmp 0xab64
movzwl -0x12(%rbp), %eax
cmpl $0x1d, %eax
jne 0xab41
movb $0x20, -0x13(%rbp)
jmp 0xab62
movzwl -0x12(%rbp), %eax
cmpl $0x1e, %eax
jl 0xab60
movzwl -0x12(%rbp), %eax
cmpl $0x27, %eax
jg 0xab60
movzwl -0x12(%rbp), %eax
subl $0x1e, %eax
addl $0x30, %eax
movb %al, -0x13(%rbp)
jmp 0xab62
jmp 0xab64
jmp 0xab66
jmp 0xab68
jmp 0xab6a
movb -0x13(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movzwl -0x12(%rbp), %ecx
movslq -0x20(%rbp), %rax
movzwl -0x1a(%rbp,%rax,2), %eax
imull %eax, %ecx
movzwl -0x2(%rbp), %eax
subl %ecx, %eax
movw %ax, -0x2(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xaabe
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw $0x0, -0x12(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x3, -0x18(%rbp)
jge 0xad31
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2120
movq %rax, %rcx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jl 0xac00
movzwl -0x12(%rbp), %eax
imull $0x28, %eax, %eax
movw %ax, -0x12(%rbp)
jmp 0xad23
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x24, %eax
jne 0xac1c
movw $0x1b, -0x1a(%rbp)
jmp 0xad12
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0xac38
movw $0x1c, -0x1a(%rbp)
jmp 0xad10
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0xac54
movw $0x1d, -0x1a(%rbp)
jmp 0xad0e
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0xac8e
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jg 0xac8e
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
subl $0x30, %eax
addl $0x1e, %eax
movw %ax, -0x1a(%rbp)
jmp 0xad0c
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x61, %eax
jl 0xacc8
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7a, %eax
jg 0xacc8
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
subl $0x61, %eax
addl $0x1, %eax
movw %ax, -0x1a(%rbp)
jmp 0xad0a
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x41, %eax
jl 0xad02
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5a, %eax
jg 0xad02
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
subl $0x41, %eax
addl $0x1, %eax
movw %ax, -0x1a(%rbp)
jmp 0xad08
movw $0x0, -0x1a(%rbp)
jmp 0xad0a
jmp 0xad0c
jmp 0xad0e
jmp 0xad10
jmp 0xad12
movzwl -0x12(%rbp), %eax
imull $0x28, %eax, %eax
movzwl -0x1a(%rbp), %ecx
addl %ecx, %eax
movw %ax, -0x12(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xabcd
movw -0x12(%rbp), %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rurban[P]dgnlib/dgnhelp.cpp
// Function: DGNGetLineStyleName(DGNInfo*, DGNElemMultiPoint*, char*)
int DGNGetLineStyleName(DGNInfo *psDGN, DGNElemMultiPoint *psLine,
                        char szLineStyle[65] )
{
    if (psLine->core.attr_bytes > 0 &&
        psLine->core.attr_data[1] == 0x10 &&
        psLine->core.attr_data[2] == 0xf9 &&
        psLine->core.attr_data[3] == 0x79)
    {
#ifdef notdef
        for (int i=0;i<SYMBOL_TABLE_SIZE;i++)
        {
            if (*((unsigned char*)psDGN->buffer + 0x21e5 + i) == psLine->core.attr_data[4] &&
                *((unsigned char*)psDGN->buffer + 0x21e6 + i) == psLine->core.attr_data[5] &&
                *((unsigned char*)psDGN->buffer + 0x21e7 + i) == psLine->core.attr_data[6] &&
                *((unsigned char*)psDGN->buffer + 0x21e8 + i) == psLine->core.attr_data[7])
            {
                memcpy( szLineStyle, 
                        (unsigned char*)psDGN->buffer + 0x21e9 + i, 64 );
                szLineStyle[64] = '\0';
                return TRUE;
            }
        }
#endif
        return FALSE;
    }
    else
    {
        szLineStyle[0] = '\0';
        return FALSE;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x34(%rax)
jle 0xada8
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x10, %eax
jne 0xada8
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movzbl 0x2(%rax), %eax
cmpl $0xf9, %eax
jne 0xada8
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movzbl 0x3(%rax), %eax
cmpl $0x79, %eax
jne 0xada8
movl $0x0, -0x4(%rbp)
jmp 0xadb6
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x34(%rax), %eax
movl -0x1c(%rbp), %ecx
addl $0x4, %ecx
cmpl %ecx, %eax
jge 0xc52c
movl $0x0, -0x4(%rbp)
jmp 0xc5e2
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movl -0x1c(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xc560
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0xc596
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movl -0x1c(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xc59f
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x80, %eax
jne 0xc59f
movl $0x8, -0x4(%rbp)
jmp 0xc5e2
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xc5db
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movl -0x1c(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll %eax
addl $0x2, %eax
movl %eax, -0x4(%rbp)
jmp 0xc5e2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0xd2c2(%rip), %xmm1     # 0x198d0
divsd %xmm1, %xmm0
movsd 0xd2ae(%rip), %xmm1     # 0x198c8
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0xd279(%rip), %xmm1     # 0x198c0
divsd %xmm1, %xmm0
callq 0x2540
movsd 0xd260(%rip), %xmm1     # 0x198b8
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0xd220(%rip), %xmm1     # 0x198c0
divsd %xmm1, %xmm0
callq 0x20b0
movsd 0xd207(%rip), %xmm1     # 0x198b8
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xcb30
cmpl $0x0, -0x14(%rbp)
jl 0xcac5
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x20044(%rcx), %eax
jl 0xcace
movl $0x0, -0x4(%rbp)
jmp 0xcb23
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x20050(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
xorl %edx, %edx
callq 0x9cd0
cmpl $0x0, %eax
je 0xcb04
movl $0x0, -0x4(%rbp)
jmp 0xcb23
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x20384(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl $0x1, %esi
movl $0x4, %edx
callq 0x9d40
cmpq $0x4, %rax
je 0xd024
movl $0x0, -0x4(%rbp)
jmp 0xd0f4
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0xff, %eax
jne 0xd04e
movq -0x10(%rbp), %rax
movzbl 0x11(%rax), %eax
cmpl $0xff, %eax
jne 0xd04e
movl $0x0, -0x4(%rbp)
jmp 0xd0f4
movq -0x10(%rbp), %rax
movzbl 0x12(%rax), %eax
movq -0x10(%rbp), %rcx
movzbl 0x13(%rcx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x11(%rax), %eax
andl $0x7f, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
andl $0x3f, %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
addq $0x4, %rdi
movslq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl $0x2, %esi
callq 0x9d40
cmpl -0x28(%rbp), %eax
je 0xd0b1
movl $0x0, -0x4(%rbp)
jmp 0xd0f4
movl -0x28(%rbp), %ecx
shll %ecx
addl $0x4, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
cmpq $0x0, -0x18(%rbp)
je 0xd0dd
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0xd0ed
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: rurban[P]dgnlib/dgnread.cpp
// Function: DGNElemTypeHasDispHdr
int DGNElemTypeHasDispHdr( int nElemType )

{
    switch( nElemType )
    {
      case 0:
      case DGNT_TCB:
      case DGNT_CELL_LIBRARY:
      case DGNT_LEVEL_SYMBOLOGY:
      case 32:
      case 44:
      case 48:
      case 49:
      case 50:
      case 51:
      case 57:
      case 60:
      case 61:
      case 62:
      case 63:
        return FALSE;
        
      default:
        return TRUE;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x2, %eax
jb 0x109c9
jmp 0x10984
movl -0xc(%rbp), %eax
addl $-0x9, %eax
subl $0x2, %eax
jb 0x109c9
jmp 0x10991
movl -0xc(%rbp), %eax
subl $0x20, %eax
je 0x109c9
jmp 0x1099b
movl -0xc(%rbp), %eax
subl $0x2c, %eax
je 0x109c9
jmp 0x109a5
movl -0xc(%rbp), %eax
addl $-0x30, %eax
subl $0x4, %eax
jb 0x109c9
jmp 0x109b2
movl -0xc(%rbp), %eax
subl $0x39, %eax
je 0x109c9
jmp 0x109bc
movl -0xc(%rbp), %eax
addl $-0x3c, %eax
subl $0x3, %eax
ja 0x109d2
jmp 0x109c9
movl $0x0, -0x4(%rbp)
jmp 0x109d9
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x10c08
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0xa000
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x10c20
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0xa000
movq -0x10(%rbp), %rax
cmpl $0xa, 0xc(%rax)
jne 0x10ce1
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0xa000
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jge 0x10cd2
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0xa000
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0xa000
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, 0x18(%rax)
jne 0x10cc2
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rdi
callq 0xa000
jmp 0x10cc4
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x10c4a
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0xa000
jmp 0x10d06
movq -0x10(%rbp), %rax
cmpl $0x9, 0xc(%rax)
jne 0x10d04
movq -0x10(%rbp), %rax
cmpl $0x1, 0x50(%rax)
jne 0x10d02
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0xa000
jmp 0x10d04
jmp 0x10d06
movq -0x10(%rbp), %rdi
callq 0xa000
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rurban[P]dgnlib/dgnread.cpp
// Function: DGNRewind
void DGNRewind( DGNHandle hDGN )

{
    DGNInfo     *psDGN = (DGNInfo *) hDGN;

    VSIRewind( psDGN->fp );

    psDGN->next_element_id = 0;
    psDGN->in_complex_group = FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x9d20
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x20384(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: rurban[P]dgnlib/dgnread.cpp
// Function: DGNLoadTCB
int DGNLoadTCB( DGNHandle hDGN )

{
    DGNInfo     *psDGN = (DGNInfo *) hDGN;

    if( psDGN->got_tcb )
        return TRUE;

    while( !psDGN->got_tcb )
    {
        DGNElemCore *psElem = DGNReadElement( hDGN );
        if( psElem == NULL )
        {
            CPLError( CE_Failure, CPLE_AppDefined, 
                      "DGNLoadTCB() - unable to find TCB in file." );
            return FALSE;
        }
        DGNFreeElement( hDGN, psElem );
    }

    return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x20014(%rax)
je 0x111ba
movl $0x1, -0x4(%rbp)
jmp 0x1121d
jmp 0x111bc
movq -0x18(%rbp), %rax
cmpl $0x0, 0x20014(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x111d2
jmp 0x11216
movq -0x10(%rbp), %rdi
callq 0xd5e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x11207
movl $0x3, %edi
movl $0x1, %esi
leaq 0x9349(%rip), %rdx      # 0x1a540
movb $0x0, %al
callq 0x5740
movl $0x0, -0x4(%rbp)
jmp 0x1121d
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x10be0
jmp 0x111bc
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rurban[P]dgnlib/dgnread.cpp
// Function: DGNGetElementIndex
const DGNElementInfo *DGNGetElementIndex( DGNHandle hDGN, int *pnElementCount )

{
    DGNInfo     *psDGN = (DGNInfo *) hDGN;

    DGNBuildIndex( psDGN );

    if( pnElementCount != NULL )
        *pnElementCount = psDGN->element_count;
    
    return psDGN->element_index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xcb30
cmpq $0x0, -0x10(%rbp)
je 0x11268
movq -0x18(%rbp), %rax
movl 0x20044(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq 0x20050(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: rurban[P]dgnlib/dgnread.cpp
// Function: DGNGetExtents
int DGNGetExtents( DGNHandle hDGN, double * padfExtents )

{
    DGNInfo     *psDGN = (DGNInfo *) hDGN;
    DGNPoint    sMin, sMax;

    DGNBuildIndex( psDGN );

    if( !psDGN->got_bounds )
        return FALSE;

    sMin.x = psDGN->min_x - 2147483648.0;
    sMin.y = psDGN->min_y - 2147483648.0;
    sMin.z = psDGN->min_z - 2147483648.0;
    
    DGNTransformPoint( psDGN, &sMin );

    padfExtents[0] = sMin.x;
    padfExtents[1] = sMin.y;
    padfExtents[2] = sMin.z;
    
    sMax.x = psDGN->max_x - 2147483648.0;
    sMax.y = psDGN->max_y - 2147483648.0;
    sMax.z = psDGN->max_z - 2147483648.0;

    DGNTransformPoint( psDGN, &sMax );

    padfExtents[3] = sMax.x;
    padfExtents[4] = sMax.y;
    padfExtents[5] = sMax.z;

    return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xcb30
movq -0x20(%rbp), %rax
cmpl $0x0, 0x2035c(%rax)
jne 0x112ba
movl $0x0, -0x4(%rbp)
jmp 0x113d8
movq -0x20(%rbp), %rax
movl 0x20360(%rax), %eax
cvtsi2sd %rax, %xmm0
movsd 0x9067(%rip), %xmm1     # 0x1a338
movsd %xmm1, -0x58(%rbp)
subsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x20(%rbp), %rax
movl 0x20364(%rax), %eax
cvtsi2sd %rax, %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl 0x20368(%rax), %eax
cvtsi2sd %rax, %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd4f0
movsd -0x58(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x20(%rbp), %rax
movl 0x2036c(%rax), %eax
cvtsi2sd %rax, %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x20(%rbp), %rax
movl 0x20370(%rax), %eax
cvtsi2sd %rax, %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x20(%rbp), %rax
movl 0x20374(%rax), %eax
cvtsi2sd %rax, %xmm0
movsd 0x8fa7(%rip), %xmm1     # 0x1a338
subsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xd4f0
movsd -0x50(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movsd -0x48(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movsd -0x40(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x28(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rurban[P]dgnlib/dgnread.cpp
// Function: DGNParseColorTable(DGNInfo*)
static DGNElemCore *DGNParseColorTable( DGNInfo * psDGN )

{
    DGNElemCore *psElement;
    DGNElemColorTable  *psColorTable;
            
    psColorTable = (DGNElemColorTable *) 
        CPLCalloc(sizeof(DGNElemColorTable),1);
    psElement = (DGNElemCore *) psColorTable;
    psElement->stype = DGNST_COLORTABLE;

    DGNParseCore( psDGN, psElement );

    psColorTable->screen_flag = 
        psDGN->abyElem[36] + psDGN->abyElem[37] * 256;

    memcpy( psColorTable->color_info[255], psDGN->abyElem+38, 3 );
    memcpy( psColorTable->color_info, psDGN->abyElem+41, 765 ); 

    // We used to only install a color table as the default color
    // table if it was the first in the file.  But apparently we should
    // really be using the last one.  This doesn't necessarily accomplish
    // that either if the elements are being read out of order but it will
    // usually do better at least. 
    memcpy( psDGN->color_table, psColorTable->color_info, 768 );
    psDGN->got_color_table = 1;
    
    return psElement;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x358, %edi            # imm = 0x358
movl $0x1, %esi
callq 0x2fc0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x3, 0xc(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x109e0
movq -0x8(%rbp), %rax
movzbl 0x34(%rax), %ecx
movq -0x8(%rbp), %rax
movzbl 0x35(%rax), %eax
shll $0x8, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movw 0x36(%rcx), %dx
movw %dx, 0x351(%rax)
movb 0x38(%rcx), %cl
movb %cl, 0x353(%rax)
movq -0x18(%rbp), %rdi
addq $0x54, %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
addq $0x29, %rsi
movl $0x2fd, %edx            # imm = 0x2FD
callq 0x2240
movq -0x8(%rbp), %rdi
addq $0x2005c, %rdi          # imm = 0x2005C
movq -0x18(%rbp), %rsi
addq $0x54, %rsi
movl $0x300, %edx            # imm = 0x300
callq 0x2240
movq -0x8(%rbp), %rax
movl $0x1, 0x20058(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)