LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Baobaobear[P]sort/./wikisort.hpp
// Function: void InsertionSort<baobao::TestClass*, std::less<baobao::TestClass>>(baobao::TestClass*, baobao::TestClass*, std::less<baobao::TestClass>)
void InsertionSort(BidirectionalIterator first, BidirectionalIterator last, Comparison compare) {
    typedef typename std::iterator_traits<BidirectionalIterator>::value_type T;
    if (first == last) return;

    for (BidirectionalIterator cur = first + 1 ; cur != last ; ++cur) {
        BidirectionalIterator sift = cur;
        BidirectionalIterator sift_1 = cur - 1;

        // Compare first so we can avoid 2 moves for
        // an element already positioned correctly.
        if (compare(*sift, *sift_1)) {
            T tmp = *sift;
            do {
                *sift-- = *sift_1;
            } while (sift != first && compare(tmp, *--sift_1));
            *sift = tmp;
        }
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rax
cmpq 0x40(%rsp), %rax
jne 0x1daef
jmp 0x1dbc8
movq 0x48(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x40(%rsp), %rax
je 0x1dbc8
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
addq $-0x20, %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x57(%rsp), %rdi
callq 0xcd80
testb $0x1, %al
jne 0x1db3f
jmp 0x1dbb3
movq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x86a0
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdi
movq %rdi, %rax
addq $-0x20, %rax
movq %rax, 0x30(%rsp)
callq 0x8710
movq 0x30(%rsp), %rcx
xorl %eax, %eax
cmpq 0x48(%rsp), %rcx
movb %al, 0x7(%rsp)
je 0x1db9c
movq 0x28(%rsp), %rdx
addq $-0x20, %rdx
movq %rdx, 0x28(%rsp)
leaq 0x57(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xcd80
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x1db4e
movq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x8710
jmp 0x1dbb5
movq 0x38(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x38(%rsp)
jmp 0x1dafd
addq $0x58, %rsp
retq
nopl (%rax)
// File: Baobaobear[P]sort/./wikisort.hpp
// Function: baobao::TestClass* FindFirstForward<baobao::TestClass*, baobao::TestClass, std::less<baobao::TestClass>>(baobao::TestClass*, baobao::TestClass*, baobao::TestClass const&, std::less<baobao::TestClass>, unsigned long)
RandomAccessIterator FindFirstForward(RandomAccessIterator first, RandomAccessIterator last,
                                      const T & value, Comparison compare, std::size_t unique) {
    std::size_t size = std::distance(first, last);
    if (size == 0) return first;

    std::size_t skip = std::max(size / unique, (std::size_t)1);

    RandomAccessIterator index;
    for (index = first + skip ; compare(*(index - 1), value) ; index += skip) {
        if (index >= last - skip) {
            return std::lower_bound(index, last, value, compare);
        }
    }
    return std::lower_bound(index - skip, index, value, compare);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xbb40
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x1dc13
movq 0x50(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x1dcf0
movq 0x30(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x38(%rsp)
movq %rax, 0x20(%rsp)
movq $0x1, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1e050
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rax
movq 0x28(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
addq $-0x20, %rsi
movq 0x40(%rsp), %rdx
leaq 0x5f(%rsp), %rdi
callq 0xcd80
testb $0x1, %al
jne 0x1dc7a
jmp 0x1dcc9
movq 0x10(%rsp), %rax
movq 0x48(%rsp), %rcx
xorl %edx, %edx
subq 0x28(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jb 0x1dcb2
movq 0x10(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0xf130
movq %rax, 0x60(%rsp)
jmp 0x1dcf0
jmp 0x1dcb4
movq 0x28(%rsp), %rax
shlq $0x5, %rax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x1dc5c
movq 0x10(%rsp), %rdi
xorl %eax, %eax
subq 0x28(%rsp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movq 0x10(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0xf130
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: Baobaobear[P]sort/./wikisort.hpp
// Function: baobao::TestClass* FindLastBackward<baobao::TestClass*, baobao::TestClass, std::less<baobao::TestClass>>(baobao::TestClass*, baobao::TestClass*, baobao::TestClass const&, std::less<baobao::TestClass>, unsigned long)
RandomAccessIterator FindLastBackward(RandomAccessIterator first, RandomAccessIterator last,
                                      const T & value, Comparison compare, std::size_t unique) {
    std::size_t size = std::distance(first, last);
    if (size == 0) return first;

    std::size_t skip = std::max(size / unique, (std::size_t)1);

    RandomAccessIterator index;
    for (index = last - skip ; index > first && compare(value, *(index - 1)) ; index -= skip) {
        if (index < first + skip) {
            return std::upper_bound(first, index, value, compare);
        }
    }
    return std::upper_bound(index, index + skip, value, compare);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xbb40
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x1dd43
movq 0x50(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x1de43
movq 0x30(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x38(%rsp)
movq %rax, 0x20(%rsp)
movq $0x1, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1e050
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
xorl %ecx, %ecx
subq 0x28(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq 0x50(%rsp), %rcx
movb %al, 0xd(%rsp)
jbe 0x1ddbc
movq 0x40(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq $-0x20, %rdx
leaq 0x5f(%rsp), %rdi
callq 0xcd80
movb %al, 0xd(%rsp)
movb 0xd(%rsp), %al
testb $0x1, %al
jne 0x1ddc6
jmp 0x1de1e
movq 0x10(%rsp), %rax
movq 0x50(%rsp), %rcx
movq 0x28(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x1ddfc
movq 0x50(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0xf0e0
movq %rax, 0x60(%rsp)
jmp 0x1de43
jmp 0x1ddfe
movq 0x28(%rsp), %rdx
movq 0x10(%rsp), %rax
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0x1dd8e
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rax
shlq $0x5, %rax
addq %rax, %rsi
movq 0x40(%rsp), %rdx
callq 0xf0e0
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopl (%rax)
// File: rurban[P]dgnlib/dgndump.c
// Function: Usage()
static void Usage()

{
    printf( "Usage: dgndump [-e xmin ymin xmax ymax] [-s] [-r n] filename.dgn\n" );
    printf( "\n" );
    printf( "  -e xmin ymin xmax ymax: only get elements within extents.\n" );
    printf( "  -s: produce summary report of element types and levels.\n");
    printf( "  -r n: report raw binary contents of elements of type n.\n");

    exit( 1 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x16319(%rip), %rdi     # 0x19104
movb $0x0, %al
callq 0x2050
leaq 0x16e8a(%rip), %rdi     # 0x19c83
movb $0x0, %al
callq 0x2050
leaq 0x1633f(%rip), %rdi     # 0x19146
movb $0x0, %al
callq 0x2050
leaq 0x1636e(%rip), %rdi     # 0x19183
movb $0x0, %al
callq 0x2050
leaq 0x1639b(%rip), %rdi     # 0x191be
movb $0x0, %al
callq 0x2050
movl $0x1, %edi
callq 0x2380
nopw %cs:(%rax,%rax)
// File: rurban[P]dgnlib/dgndump.c
// Function: DGNDumpRawElement(void*, DGNElemCore*, _IO_FILE*)
static void DGNDumpRawElement( DGNHandle hDGN, DGNElemCore *psCore, 
                               FILE *fpOut )

{
    int         i, iChar = 0;
    char        szLine[80];

    fprintf( fpOut, "  Raw Data (%d bytes):\n", psCore->raw_bytes );
    for( i = 0; i < psCore->raw_bytes; i++ )
    {
        char    szHex[3];

        if( (i % 16) == 0 )                                             
        {
            sprintf( szLine, "%6d: %71s", i, " " );
            iChar = 0;
        }

        sprintf( szHex, "%02x", psCore->raw_data[i] );
        strncpy( szLine+8+iChar*2, szHex, 2 );
        
        if( psCore->raw_data[i] < 32 || psCore->raw_data[i] > 127 )
            szLine[42+iChar] = '.';
        else
            szLine[42+iChar] = psCore->raw_data[i];

        if( i == psCore->raw_bytes - 1 || (i+1) % 16 == 0 )
        {
            fprintf( fpOut, "%s\n", szLine );
        }

        iChar++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x40(%rax), %edx
leaq 0x16389(%rip), %rsi     # 0x191f9
movb $0x0, %al
callq 0x2410
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x40(%rcx), %eax
jge 0x2fa8
movl -0x1c(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x2ec1
leaq -0x70(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq 0x16365(%rip), %rsi     # 0x19211
leaq 0x16a6a(%rip), %rcx     # 0x1991d
movb $0x0, %al
callq 0x20a0
movl $0x0, -0x20(%rbp)
leaq -0x73(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %edx
leaq 0x17209(%rip), %rsi     # 0x1a0e5
movb $0x0, %al
callq 0x20a0
leaq -0x70(%rbp), %rdi
addq $0x8, %rdi
movl -0x20(%rbp), %eax
shll %eax
cltq
addq %rax, %rdi
leaq -0x73(%rbp), %rsi
movl $0x2, %edx
callq 0x2160
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jl 0x2f2d
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x7f, %eax
jle 0x2f3c
movl -0x20(%rbp), %eax
addl $0x2a, %eax
cltq
movb $0x2e, -0x70(%rbp,%rax)
jmp 0x2f57
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %cl
movl -0x20(%rbp), %eax
addl $0x2a, %eax
cltq
movb %cl, -0x70(%rbp,%rax)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x40(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x2f7b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl $0x10, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x2f91
movq -0x18(%rbp), %rdi
leaq -0x70(%rbp), %rdx
leaq 0x16604(%rip), %rsi     # 0x1958e
movb $0x0, %al
callq 0x2410
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2e7e
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLCalloc
void *CPLCalloc( size_t nCount, size_t nSize )

{
    void        *pReturn;

    if( nSize * nCount == 0 )
        return NULL;
    
    pReturn = VSICalloc( nCount, nSize );
    if( pReturn == NULL )
    {
        CPLError( CE_Fatal, CPLE_OutOfMemory,
                  "CPLCalloc(): Out of memory allocating %d bytes.\n",
                  nSize * nCount );
    }

    return pReturn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
imulq -0x10(%rbp), %rax
cmpq $0x0, %rax
jne 0x2fe9
movq $0x0, -0x8(%rbp)
jmp 0x302a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9f80
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3022
movq -0x18(%rbp), %rcx
imulq -0x10(%rbp), %rcx
movl $0x4, %edi
movl $0x2, %esi
leaq 0x16245(%rip), %rdx     # 0x19260
movb $0x0, %al
callq 0x5740
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLMalloc
void *CPLMalloc( size_t nSize )

{
    void        *pReturn;

    CPLVerifyConfiguration();

    if( nSize == 0 )
        return NULL;

    if( (ssize_t)nSize < 0 )
    {
        CPLError( CE_Failure, CPLE_AppDefined,
                  "CPLMalloc(%ld): Silly size requested.\n",
                  (long)nSize );
        return NULL;
    }
    
    pReturn = VSIMalloc( nSize );
    if( pReturn == NULL )
    {
        CPLError( CE_Fatal, CPLE_OutOfMemory,
                  "CPLMalloc(): Out of memory allocating %ld bytes.\n",
                  (long)nSize );
    }

    return pReturn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x30e0
cmpq $0x0, -0x10(%rbp)
jne 0x3062
movq $0x0, -0x8(%rbp)
jmp 0x30c7
cmpq $0x0, -0x10(%rbp)
jge 0x308f
movq -0x10(%rbp), %rcx
movl $0x3, %edi
movl $0x1, %esi
leaq 0x16213(%rip), %rdx     # 0x19291
movb $0x0, %al
callq 0x5740
movq $0x0, -0x8(%rbp)
jmp 0x30c7
movq -0x10(%rbp), %rdi
callq 0x9fb0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x30bf
movq -0x10(%rbp), %rcx
movl $0x4, %edi
movl $0x2, %esi
leaq 0x16200(%rip), %rdx     # 0x192b8
movb $0x0, %al
callq 0x5740
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLRealloc
void * CPLRealloc( void * pData, size_t nNewSize )

{
    void        *pReturn;

    if ( nNewSize == 0 )
    {
        VSIFree(pData);
        return NULL;
    }

    if( (ssize_t)nNewSize < 0 )
    {
        CPLError( CE_Failure, CPLE_AppDefined,
                  "CPLRealloc(%ld): Silly size requested.\n",
                  (long)nNewSize );
        return NULL;
    }
    
    if( pData == NULL )
        pReturn = VSIMalloc( nNewSize );
    else
        pReturn = VSIRealloc( pData, nNewSize );
    
    if( pReturn == NULL )
    {
        CPLError( CE_Fatal, CPLE_OutOfMemory,
                  "CPLRealloc(): Out of memory allocating %ld bytes.\n",
                  (long)nNewSize );
    }

    return pReturn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x314a
movq -0x10(%rbp), %rdi
callq 0xa000
movq $0x0, -0x8(%rbp)
jmp 0x31c9
cmpq $0x0, -0x18(%rbp)
jge 0x3177
movq -0x18(%rbp), %rcx
movl $0x3, %edi
movl $0x1, %esi
leaq 0x16184(%rip), %rdx     # 0x192ea
movb $0x0, %al
callq 0x5740
movq $0x0, -0x8(%rbp)
jmp 0x31c9
cmpq $0x0, -0x10(%rbp)
jne 0x318d
movq -0x18(%rbp), %rdi
callq 0x9fb0
movq %rax, -0x20(%rbp)
jmp 0x319e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9fd0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x31c1
movq -0x18(%rbp), %rcx
movl $0x4, %edi
movl $0x2, %esi
leaq 0x16158(%rip), %rdx     # 0x19312
movb $0x0, %al
callq 0x5740
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLStrdup
char *CPLStrdup( const char * pszString )

{
    char        *pszReturn;

    if( pszString == NULL )
        pszString = "";

    pszReturn = VSIStrdup( pszString );
        
    if( pszReturn == NULL )
    {
        CPLError( CE_Fatal, CPLE_OutOfMemory,
                  "CPLStrdup(): Out of memory allocating %d bytes.\n",
                  strlen(pszString) );
        
    }
    
    return( pszReturn );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x31fe
leaq 0x16a8a(%rip), %rax     # 0x19c84
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa030
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3236
movq -0x8(%rbp), %rdi
callq 0x2120
movq %rax, %rcx
movl $0x4, %edi
movl $0x2, %esi
leaq 0x16116(%rip), %rdx     # 0x19345
movb $0x0, %al
callq 0x5740
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLReadLineBuffer(int)
static char *CPLReadLineBuffer( int nRequiredSize )

{
    
/* -------------------------------------------------------------------- */
/*      A required size of -1 means the buffer should be freed.         */
/* -------------------------------------------------------------------- */
    if( nRequiredSize == -1 )
    {
        if( CPLGetTLS( CTLS_RLBUFFERINFO ) != NULL )
        {
            CPLFree( CPLGetTLS( CTLS_RLBUFFERINFO ) );
            CPLSetTLS( CTLS_RLBUFFERINFO, NULL, FALSE );
        }
        return NULL;
    }

/* -------------------------------------------------------------------- */
/*      If the buffer doesn't exist yet, create it.                     */
/* -------------------------------------------------------------------- */
    GUInt32 *pnAlloc = (GUInt32 *) CPLGetTLS( CTLS_RLBUFFERINFO );

    if( pnAlloc == NULL )
    {
        pnAlloc = (GUInt32 *) CPLMalloc(200);
        *pnAlloc = 196;
        CPLSetTLS( CTLS_RLBUFFERINFO, pnAlloc, TRUE );
    }

/* -------------------------------------------------------------------- */
/*      If it is too small, grow it bigger.                             */
/* -------------------------------------------------------------------- */
    if( (int) *pnAlloc < nRequiredSize+1 )
    {
        int nNewSize = nRequiredSize + 4 + 500;

        pnAlloc = (GUInt32 *) CPLRealloc(pnAlloc,nNewSize);
        if( pnAlloc == NULL )
        {
            CPLSetTLS( CTLS_RLBUFFERINFO, NULL, FALSE );
            return NULL;
        }
            
        *pnAlloc = nNewSize - 4;
        CPLSetTLS( CTLS_RLBUFFERINFO, pnAlloc, TRUE );
    }

    return (char *) (pnAlloc+1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x35d0
movl $0x1, %edi
callq 0x6700
cmpq $0x0, %rax
je 0x35c3
movl $0x1, %edi
callq 0x6700
movq %rax, %rdi
callq 0xa000
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x6760
movq $0x0, -0x8(%rbp)
jmp 0x3685
movl $0x1, %edi
callq 0x6700
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x360d
movl $0xc8, %edi
callq 0x3040
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0xc4, (%rax)
movq -0x18(%rbp), %rsi
movl $0x1, %edx
movl %edx, %edi
callq 0x6760
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x3679
movl -0xc(%rbp), %eax
addl $0x4, %eax
addl $0x1f4, %eax            # imm = 0x1F4
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x3120
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x365d
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x6760
movq $0x0, -0x8(%rbp)
jmp 0x3685
movl -0x1c(%rbp), %ecx
subl $0x4, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rsi
movl $0x1, %edx
movl %edx, %edi
callq 0x6760
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLScanString
char *CPLScanString( const char *pszString, int nMaxLength,
                     int bTrimSpaces, int bNormalize )
{
    char    *pszBuffer;

    if ( !pszString )
        return NULL;

    if ( !nMaxLength )
        return CPLStrdup( "" );

    pszBuffer = (char *)CPLMalloc( nMaxLength + 1 );
    if ( !pszBuffer )
        return NULL;

    strncpy( pszBuffer, pszString,  nMaxLength );
    pszBuffer[nMaxLength] = '\0';

    if ( bTrimSpaces )
    {
        size_t  i = strlen( pszBuffer );
        while ( i-- > 0 && isspace(pszBuffer[i]) )
            pszBuffer[i] = '\0';
    }

    if ( bNormalize )
    {
        size_t  i = strlen( pszBuffer );
        while ( i-- > 0 )
        {
            if ( pszBuffer[i] == ':' )
                pszBuffer[i] = '_';
        }
    }

    return pszBuffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3929
movq $0x0, -0x8(%rbp)
jmp 0x3a38
cmpl $0x0, -0x14(%rbp)
jne 0x3944
leaq 0x1634e(%rip), %rdi     # 0x19c84
callq 0x31e0
movq %rax, -0x8(%rbp)
jmp 0x3a38
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x3040
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x396a
movq $0x0, -0x8(%rbp)
jmp 0x3a38
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x2160
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cmpl $0x0, -0x18(%rbp)
je 0x39e7
movq -0x28(%rbp), %rdi
callq 0x2120
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x39(%rbp)
jbe 0x39ce
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2060
cmpl $0x0, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x39d7
jmp 0x39e5
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x399a
jmp 0x39e7
cmpl $0x0, -0x1c(%rbp)
je 0x3a30
movq -0x28(%rbp), %rdi
callq 0x2120
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x38(%rbp)
cmpq $0x0, %rax
jbe 0x3a2e
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
jne 0x3a2c
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movb $0x5f, (%rax,%rcx)
jmp 0x39fa
jmp 0x3a30
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLScanLong
long CPLScanLong( const char *pszString, int nMaxLength )
{
    long    iValue;
    char    *pszValue = (char *)CPLMalloc( nMaxLength + 1);

/* -------------------------------------------------------------------- */
/*      Compute string into local buffer, and terminate it.             */
/* -------------------------------------------------------------------- */
    strncpy( pszValue, pszString, nMaxLength );
    pszValue[nMaxLength] = '\0';

/* -------------------------------------------------------------------- */
/*      Use atol() to fetch out the result                              */
/* -------------------------------------------------------------------- */
    iValue = atol( pszValue );

    CPLFree( pszValue );
    return iValue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x3040
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x2160
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rdi
callq 0x2370
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa000
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLScanPointer
void *CPLScanPointer( const char *pszString, int nMaxLength )
{
    void  *pResult;
    char  szTemp[128];

/* -------------------------------------------------------------------- */
/*      Compute string into local buffer, and terminate it.             */
/* -------------------------------------------------------------------- */
    if( nMaxLength > (int) sizeof(szTemp)-1 )
        nMaxLength = sizeof(szTemp)-1;

    strncpy( szTemp, pszString, nMaxLength );
    szTemp[nMaxLength] = '\0';

/* -------------------------------------------------------------------- */
/*      On MSVC we have to scanf pointer values without the 0x          */
/*      prefix.                                                         */
/* -------------------------------------------------------------------- */
    if( EQUALN(szTemp,"0x",2) )
    {
        pResult = NULL;

#if defined(WIN32) && defined(_MSC_VER)
        sscanf( szTemp+2, "%p", &pResult );
#else
        sscanf( szTemp, "%p", &pResult );
#endif
    }
    
    else
    {
        pResult = (void *) CPLScanUIntBig( szTemp, nMaxLength );
    }

    return pResult;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x7f, -0xc(%rbp)
jle 0x3b2f
movl $0x7f, -0xc(%rbp)
leaq -0xa0(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x2160
movslq -0xc(%rbp), %rax
movb $0x0, -0xa0(%rbp,%rax)
leaq -0xa0(%rbp), %rdi
leaq 0x1662b(%rip), %rsi     # 0x1a188
movl $0x2, %edx
callq 0x23c0
cmpl $0x0, %eax
jne 0x3b8f
movq $0x0, -0x18(%rbp)
leaq -0xa0(%rbp), %rdi
leaq 0x15845(%rip), %rsi     # 0x193c7
leaq -0x18(%rbp), %rdx
movb $0x0, %al
callq 0x22e0
jmp 0x3ba2
leaq -0xa0(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x3ab0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLScanDouble
double CPLScanDouble( const char *pszString, int nMaxLength, char *pszLocale )
{
    int     i;
    double  dfValue;
    char    *pszValue = (char *)CPLMalloc( nMaxLength + 1);

/* -------------------------------------------------------------------- */
/*      Compute string into local buffer, and terminate it.             */
/* -------------------------------------------------------------------- */
    strncpy( pszValue, pszString, nMaxLength );
    pszValue[nMaxLength] = '\0';

/* -------------------------------------------------------------------- */
/*      Make a pass through converting 'D's to 'E's.                    */
/* -------------------------------------------------------------------- */
    for( i = 0; i < nMaxLength; i++ )
        if ( pszValue[i] == 'd' || pszValue[i] == 'D' )
            pszValue[i] = 'E';

/* -------------------------------------------------------------------- */
/*      Use atof() to fetch out the result                              */
/* -------------------------------------------------------------------- */
#if defined(HAVE_LOCALE_H) && defined(HAVE_SETLOCALE)
    char        *pszCurLocale = NULL;

    if ( pszLocale || EQUAL( pszLocale, "" ) )
    {
        // Save the current locale
        pszCurLocale = setlocale(LC_ALL, NULL );
        // Set locale to the specified value
        setlocale(LC_ALL, pszLocale );
    }
#endif

    dfValue = atof( pszValue );

#if defined(HAVE_LOCALE_H) && defined(HAVE_SETLOCALE)
    // Restore stored locale back
    if ( pszCurLocale )
        setlocale(LC_ALL, pszCurLocale );
#endif

    CPLFree( pszValue );
    return dfValue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x3040
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x2160
movq -0x30(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3c3c
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x64, %eax
je 0x3c23
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x44, %eax
jne 0x3c2f
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x45, (%rax,%rcx)
jmp 0x3c31
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3bf9
movq -0x30(%rbp), %rdi
callq 0x23a0
movsd %xmm0, -0x28(%rbp)
movq -0x30(%rbp), %rdi
callq 0xa000
movsd -0x28(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLPrintString
int CPLPrintString( char *pszDest, const char *pszSrc, int nMaxLen )
{
    char    *pszTemp = pszDest;
    int     nChars = 0;

    if ( !pszDest )
        return 0;

    if ( !pszSrc )
    {
        *pszDest = '\0';
        return 1;
    }

    while ( nChars < nMaxLen && *pszSrc )
    {
        *pszTemp++ = *pszSrc++;
        nChars++;
    }

    return nChars;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3c8e
movl $0x0, -0x4(%rbp)
jmp 0x3cfd
cmpq $0x0, -0x18(%rbp)
jne 0x3ca5
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x3cfd
jmp 0x3ca7
movl -0x2c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x1c(%rbp), %ecx
movb %al, -0x2d(%rbp)
jge 0x3cc1
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x3cca
jmp 0x3cf7
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3ca7
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLPrintStringFill
int CPLPrintStringFill( char *pszDest, const char *pszSrc, int nMaxLen )
{
    char    *pszTemp = pszDest;

    if ( !pszDest )
        return 0;

    if ( !pszSrc )
    {
        memset( pszDest, ' ', nMaxLen );
        return nMaxLen;
    }

    while ( nMaxLen && *pszSrc )
    {
        *pszTemp++ = *pszSrc++;
        nMaxLen--;
    }

    if ( nMaxLen )
        memset( pszTemp, ' ', nMaxLen );

    return nMaxLen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3d3e
movl $0x0, -0x4(%rbp)
jmp 0x3dcd
cmpq $0x0, -0x18(%rbp)
jne 0x3d5f
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
movl $0x20, %esi
callq 0x2170
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3dcd
jmp 0x3d61
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x29(%rbp)
je 0x3d79
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x3d82
jmp 0x3daf
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3d61
cmpl $0x0, -0x1c(%rbp)
je 0x3dc7
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
movl $0x20, %esi
callq 0x2170
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLPrintInt32
int CPLPrintInt32( char *pszBuffer, GInt32 iValue, int nMaxLen )
{
    char    szTemp[64];

    if ( !pszBuffer )
        return 0;

    if ( nMaxLen >= 64 )
        nMaxLen = 63;

#if UINT_MAX == 65535
    sprintf( szTemp, "%*ld", nMaxLen, iValue );
#else
    sprintf( szTemp, "%*d", nMaxLen, iValue );
#endif

    return CPLPrintString( pszBuffer, szTemp, nMaxLen );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3e02
movl $0x0, -0x4(%rbp)
jmp 0x3e3a
cmpl $0x40, -0x18(%rbp)
jl 0x3e0f
movl $0x3f, -0x18(%rbp)
leaq -0x60(%rbp), %rdi
movl -0x18(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq 0x1559c(%rip), %rsi     # 0x193bc
movb $0x0, %al
callq 0x20a0
movq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl -0x18(%rbp), %edx
callq 0x3c60
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLPrintUIntBig
int CPLPrintUIntBig( char *pszBuffer, GUIntBig iValue, int nMaxLen )
{
    char    szTemp[64];

    if ( !pszBuffer )
        return 0;

    if ( nMaxLen >= 64 )
        nMaxLen = 63;

#if defined(WIN32) && defined(_MSC_VER)
    sprintf( szTemp, "%*I64d", nMaxLen, iValue );
# elif HAVE_LONG_LONG
    sprintf( szTemp, "%*lld", nMaxLen, (long long) iValue );
//    sprintf( szTemp, "%*Ld", nMaxLen, (long long) iValue );
#else
    sprintf( szTemp, "%*ld", nMaxLen, iValue );
#endif

    return CPLPrintString( pszBuffer, szTemp, nMaxLen );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3e73
movl $0x0, -0x4(%rbp)
jmp 0x3eac
cmpl $0x40, -0x1c(%rbp)
jl 0x3e80
movl $0x3f, -0x1c(%rbp)
leaq -0x60(%rbp), %rdi
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rcx
leaq 0x1552e(%rip), %rsi     # 0x193c0
movb $0x0, %al
callq 0x20a0
movq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x3c60
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLPrintPointer
int CPLPrintPointer( char *pszBuffer, void *pValue, int nMaxLen )
{
    char    szTemp[64];

    if ( !pszBuffer )
        return 0;

    if ( nMaxLen >= 64 )
        nMaxLen = 63;

    sprintf( szTemp, "%p", pValue );

    // On windows, and possibly some other platforms the sprintf("%p")
    // does not prefix things with 0x so it is hard to know later if the
    // value is hex encoded.  Fix this up here. 

    if( !EQUALN(szTemp,"0x",2) )
        sprintf( szTemp, "0x%p", pValue );

    return CPLPrintString( pszBuffer, szTemp, nMaxLen );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3ee3
movl $0x0, -0x4(%rbp)
jmp 0x3f49
cmpl $0x40, -0x1c(%rbp)
jl 0x3ef0
movl $0x3f, -0x1c(%rbp)
leaq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x154c8(%rip), %rsi     # 0x193c7
movb $0x0, %al
callq 0x20a0
leaq -0x60(%rbp), %rdi
leaq 0x16277(%rip), %rsi     # 0x1a188
movl $0x2, %edx
callq 0x23c0
cmpl $0x0, %eax
je 0x3f36
leaq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x15496(%rip), %rsi     # 0x193c5
movb $0x0, %al
callq 0x20a0
movq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x3c60
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLPrintDouble
int CPLPrintDouble( char *pszBuffer, const char *pszFormat,
                    double dfValue, char *pszLocale )
{

#define DOUBLE_BUFFER_SIZE 64

    char    szTemp[DOUBLE_BUFFER_SIZE];
    int     i;

    if ( !pszBuffer )
        return 0;

#if defined(HAVE_LOCALE_H) && defined(HAVE_SETLOCALE)
    char        *pszCurLocale = NULL;

    if ( pszLocale || EQUAL( pszLocale, "" ) )
    {
        // Save the current locale
        pszCurLocale = setlocale(LC_ALL, NULL );
        // Set locale to the specified value
        setlocale( LC_ALL, pszLocale );
    }
#endif

#if defined(HAVE_SNPRINTF)
    snprintf( szTemp, DOUBLE_BUFFER_SIZE, pszFormat, dfValue );
#else
    sprintf( szTemp, pszFormat, dfValue );
#endif
    szTemp[DOUBLE_BUFFER_SIZE - 1] = '\0';

    for( i = 0; szTemp[i] != '\0'; i++ )
    {
        if( szTemp[i] == 'E' || szTemp[i] == 'e' )
            szTemp[i] = 'D';
    }

#if defined(HAVE_LOCALE_H) && defined(HAVE_SETLOCALE)
    // Restore stored locale back
    if ( pszCurLocale )
        setlocale( LC_ALL, pszCurLocale );
#endif

    return CPLPrintString( pszBuffer, szTemp, 64 );

#undef DOUBLE_BUFFER_SIZE

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3f8c
movl $0x0, -0x4(%rbp)
jmp 0x4005
leaq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rdx
movsd -0x20(%rbp), %xmm0
movl $0x40, %esi
movb $0x1, %al
callq 0x24a0
movb $0x0, -0x31(%rbp)
movl $0x0, -0x74(%rbp)
movslq -0x74(%rbp), %rax
movsbl -0x70(%rbp,%rax), %eax
cmpl $0x0, %eax
je 0x3ff0
movslq -0x74(%rbp), %rax
movsbl -0x70(%rbp,%rax), %eax
cmpl $0x45, %eax
je 0x3fda
movslq -0x74(%rbp), %rax
movsbl -0x70(%rbp,%rax), %eax
cmpl $0x65, %eax
jne 0x3fe3
movslq -0x74(%rbp), %rax
movb $0x44, -0x70(%rbp,%rax)
jmp 0x3fe5
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x3fb0
movq -0x10(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0x40, %edx
callq 0x3c60
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLPrintTime
int CPLPrintTime( char *pszBuffer, int nMaxLen, const char *pszFormat,
                  const struct tm *poBrokenTime, char *pszLocale )
{
    char    *pszTemp = (char *)CPLMalloc( (nMaxLen + 1) * sizeof(char) );
    int     nChars;

#if defined(HAVE_LOCALE_H) && defined(HAVE_SETLOCALE)
    char        *pszCurLocale = NULL;

    if ( pszLocale || EQUAL( pszLocale, "" ) )
    {
        // Save the current locale
        pszCurLocale = setlocale(LC_ALL, NULL );
        // Set locale to the specified value
        setlocale( LC_ALL, pszLocale );
    }
#endif
    
    if ( !strftime( pszTemp, nMaxLen + 1, pszFormat, poBrokenTime ) )
        memset( pszTemp, 0, nMaxLen + 1);

#if defined(HAVE_LOCALE_H) && defined(HAVE_SETLOCALE)
    // Restore stored locale back
    if ( pszCurLocale )
        setlocale( LC_ALL, pszCurLocale );
#endif

    nChars = CPLPrintString( pszBuffer, pszTemp, nMaxLen );

    CPLFree( pszTemp );

    return nChars;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x3040
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x2230
cmpq $0x0, %rax
jne 0x4085
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x2170
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0x3c60
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
callq 0xa000
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLGetConfigOption
const char * CPL_STDCALL
CPLGetConfigOption( const char *pszKey, const char *pszDefault )

{
    const char *pszResult = NULL;

    {
        CPLMutexHolderD( &hConfigMutex );

        pszResult = CSLFetchNameValue( (char **) papszConfigOptions, pszKey );
    }

#if !defined(WIN32CE) 
    if( pszResult == NULL )
        pszResult = getenv( pszKey );
#endif
    
    if( pszResult == NULL )
        return pszDefault;
    else
        return pszResult;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
leaq 0x1b529(%rip), %rsi     # 0x1f5f8
leaq 0x15325(%rip), %rdx     # 0x193fb
leaq -0x38(%rbp), %rdi
movsd 0x1513e(%rip), %xmm0    # 0x19220
movl $0x5b3, %ecx            # imm = 0x5B3
callq 0x6370
movq 0x1b50d(%rip), %rdi     # 0x1f600
movq -0x10(%rbp), %rsi
callq 0x8630
movq %rax, -0x50(%rbp)
jmp 0x4102
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6390
cmpq $0x0, -0x20(%rbp)
jne 0x4140
movq -0x10(%rbp), %rdi
callq 0x2390
movq %rax, -0x20(%rbp)
jmp 0x4140
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6390
jmp 0x4163
cmpq $0x0, -0x20(%rbp)
jne 0x4151
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4159
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x24f0
nopl (%rax)
// File: rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLStat
int CPLStat( const char *pszPath, VSIStatBuf *psStatBuf )

{
    if( strlen(pszPath) == 2 && pszPath[1] == ':' )
    {
        char    szAltPath[10];
        
        strncpy( szAltPath, pszPath, 10 );
        strcat( szAltPath, "\\" );
        return VSIStat( szAltPath, psStatBuf );
    }
    else
        return VSIStat( pszPath, psStatBuf );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2120
cmpq $0x2, %rax
jne 0x42e0
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3a, %eax
jne 0x42e0
leaq -0x22(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xa, %edx
callq 0x2160
leaq -0x22(%rbp), %rdi
leaq 0x153ac(%rip), %rsi     # 0x19675
callq 0x2500
leaq -0x22(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa050
movl %eax, -0x4(%rbp)
jmp 0x42f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa050
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: rurban[P]dgnlib/cpl_conv.cpp
// Function: proj_strtod(char*, char**)
static double
proj_strtod(char *nptr, char **endptr) 

{
    char c, *cp = nptr;
    double result;

    /*
     * Scan for characters which cause problems with VC++ strtod()
     */
    while ((c = *cp) != '\0') {
        if (c == 'd' || c == 'D') {

            /*
             * Found one, so NUL it out, call strtod(),
             * then restore it and return
             */
            *cp = '\0';
            result = strtod(nptr, endptr);
            *cp = c;
            return result;
        }
        ++cp;
    }

    /* no offending characters, just handle normally */

    return strtod(nptr, endptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x4697
movsbl -0x19(%rbp), %eax
cmpl $0x64, %eax
je 0x465b
movsbl -0x19(%rbp), %eax
cmpl $0x44, %eax
jne 0x4689
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2210
movsd %xmm0, -0x30(%rbp)
movb -0x19(%rbp), %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x46a9
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4638
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2210
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLPackedDMSToDec
double CPLPackedDMSToDec( double dfPacked )
{
    double  dfDegrees, dfMinutes, dfSeconds, dfSign;

    dfSign = ( dfPacked < 0.0 )? -1 : 1;
        
    dfSeconds = ABS( dfPacked );
    dfDegrees = floor(dfSeconds / 1000000.0);
    dfSeconds = dfSeconds - dfDegrees * 1000000.0;
    dfMinutes = floor(dfSeconds / 1000.0);
    dfSeconds = dfSeconds - dfMinutes * 1000.0;
    dfSeconds = dfSign * ( dfDegrees * 3600.0 + dfMinutes * 60.0 + dfSeconds);
    dfDegrees = dfSeconds / 3600.0;

    return dfDegrees;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm1
xorps %xmm0, %xmm0
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
ucomisd %xmm1, %xmm0
cmoval %ecx, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jbe 0x48fd
movsd 0x1494f(%rip), %xmm0    # 0x19240
mulsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x4907
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x1493a(%rip), %xmm1    # 0x19258
divsd %xmm1, %xmm0
callq 0x24d0
movsd %xmm0, -0x10(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x10(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x14903(%rip), %xmm2    # 0x19258
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x148b1(%rip), %xmm1    # 0x19220
divsd %xmm1, %xmm0
callq 0x24d0
movsd %xmm0, -0x18(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x1487a(%rip), %xmm2    # 0x19220
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movsd 0x1488b(%rip), %xmm2    # 0x19250
mulsd -0x18(%rbp), %xmm2
movsd 0x14876(%rip), %xmm3    # 0x19248
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
addsd -0x20(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x14853(%rip), %xmm1    # 0x19248
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLDecToPackedDMS
double CPLDecToPackedDMS( double dfDec )
{
    double  dfDegrees, dfMinutes, dfSeconds, dfSign;

    dfSign = ( dfDec < 0.0 )? -1 : 1;

    dfDec = ABS( dfDec );
    dfDegrees = floor( dfDec );
    dfMinutes = floor( ( dfDec - dfDegrees ) * 60.0 );
    dfSeconds = ( dfDec - dfDegrees ) * 3600.0 - dfMinutes * 60.0;

    return dfSign * (dfDegrees * 1000000.0 + dfMinutes * 1000.0 + dfSeconds);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm1
xorps %xmm0, %xmm0
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
ucomisd %xmm1, %xmm0
cmoval %ecx, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jbe 0x4a5d
movsd 0x147ef(%rip), %xmm0    # 0x19240
mulsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x4a67
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x24d0
movsd %xmm0, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movsd 0x147be(%rip), %xmm1    # 0x19250
mulsd %xmm1, %xmm0
callq 0x24d0
movsd %xmm0, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movsd 0x1479e(%rip), %xmm1    # 0x19250
mulsd -0x18(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movsd 0x14772(%rip), %xmm2    # 0x19248
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movsd 0x1472b(%rip), %xmm2    # 0x19220
mulsd -0x18(%rbp), %xmm2
movsd 0x14756(%rip), %xmm3    # 0x19258
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
addsd -0x20(%rbp), %xmm1
mulsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: rurban[P]dgnlib/cpl_conv.cpp
// Function: CPLStringToComplex
void CPL_DLL CPLStringToComplex( const char *pszString, 
                                 double *pdfReal, double *pdfImag )

{
    int  i;
    int  iPlus = -1, iImagEnd = -1;

    while( *pszString == ' ' )
        pszString++;

    *pdfReal = atof(pszString);
    *pdfImag = 0.0;

    for( i = 0; pszString[i] != '\0' && pszString[i] != ' ' && i < 100; i++ )
    {
        if( pszString[i] == '+' && i > 0 )
            iPlus = i;
        if( pszString[i] == '-' && i > 0 )
            iPlus = i;
        if( pszString[i] == 'i' )
            iImagEnd = i;
    }

    if( iPlus > -1 && iImagEnd > -1 && iPlus < iImagEnd )
    {
        *pdfImag = atof(pszString + iPlus);
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x4b5c
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x4b42
movq -0x8(%rbp), %rdi
callq 0x23a0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x25(%rbp)
je 0x4bb5
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x20, %ecx
movb %al, -0x25(%rbp)
je 0x4bb5
cmpl $0x64, -0x1c(%rbp)
setl %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x4bbe
jmp 0x4c1f
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2b, %eax
jne 0x4bdb
cmpl $0x0, -0x1c(%rbp)
jle 0x4bdb
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x4bf8
cmpl $0x0, -0x1c(%rbp)
jle 0x4bf8
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x69, %eax
jne 0x4c0f
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x4c11
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4b7f
cmpl $-0x1, -0x20(%rbp)
jle 0x4c4b
cmpl $-0x1, -0x24(%rbp)
jle 0x4c4b
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x4c4b
movq -0x8(%rbp), %rdi
movslq -0x20(%rbp), %rax
addq %rax, %rdi
callq 0x23a0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)