LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/rurban[P]dgnlib/dgnread.cpp
// Function: DGNInverseTransformPointToInt(DGNInfo*, DGNPoint*, unsigned char*)
void DGNInverseTransformPointToInt( DGNInfo *psDGN, DGNPoint *psPoint,
                                    unsigned char *pabyTarget )

{
    double     adfCT[3];
    int        i;

    adfCT[0] = (psPoint->x + psDGN->origin_x) / psDGN->scale;
    adfCT[1] = (psPoint->y + psDGN->origin_y) / psDGN->scale;
    adfCT[2] = (psPoint->z + psDGN->origin_z) / psDGN->scale;

    for( i = 0; i < psDGN->dimension; i++ )
    {
        GInt32 nCTI;
        unsigned char *pabyCTI = (unsigned char *) &nCTI;

        nCTI = (GInt32) MAX(-2147483647,MIN(2147483647,adfCT[i]));
        
#ifdef WORDS_BIGENDIAN 
        pabyTarget[i*4+0] = pabyCTI[1];
        pabyTarget[i*4+1] = pabyCTI[0];
        pabyTarget[i*4+2] = pabyCTI[3];
        pabyTarget[i*4+3] = pabyCTI[2];
#else
        pabyTarget[i*4+3] = pabyCTI[1];
        pabyTarget[i*4+2] = pabyCTI[0];
        pabyTarget[i*4+1] = pabyCTI[3];
        pabyTarget[i*4+0] = pabyCTI[2];
#endif        
    }
}

// Assembly:
movsd 0x20020(%rdi), %xmm0
movupd (%rsi), %xmm1
movupd 0x20028(%rdi), %xmm2
addpd %xmm1, %xmm2
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
divpd %xmm1, %xmm2
movapd %xmm2, -0x18(%rsp)
movsd 0x10(%rsi), %xmm1
addsd 0x20038(%rdi), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, -0x8(%rsp)
cmpl $0x0, 0x20018(%rdi)
jle 0xae75
xorl %eax, %eax
movsd 0x4e18(%rip), %xmm0     # 0xfc28
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movsd 0x58ab(%rip), %xmm1     # 0x106c8
movsd -0x18(%rsp,%rax,8), %xmm2
xorl %esi, %esi
ucomisd %xmm0, %xmm2
setbe %sil
addl %esi, %esi
addl %ecx, %esi
ucomisd %xmm2, %xmm1
cmovbel %ecx, %esi
ucomisd %xmm0, %xmm2
cvttsd2si %xmm2, %r8d
cmoval %esi, %r8d
ucomisd %xmm2, %xmm1
cmoval %esi, %r8d
movl %r8d, %esi
movw %r8w, 0x2(%rdx,%rax,4)
shrl $0x10, %r8d
shrl $0x18, %esi
movb %sil, 0x1(%rdx,%rax,4)
movb %r8b, (%rdx,%rax,4)
incq %rax
movslq 0x20018(%rdi), %rsi
cmpq %rsi, %rax
jl 0xae1d
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movl $0x1, %ebx
cmpl $0x0, 0x20014(%rdi)
jne 0xaec6
movq %rdi, %r14
movq %r14, %rdi
callq 0x8db3
testq %rax, %rax
je 0xaeac
movq %rax, %rsi
callq 0xac11
cmpl $0x0, 0x20014(%r14)
je 0xae8b
jmp 0xaec6
leaq 0x5a3d(%rip), %rdx      # 0x108f0
xorl %ebx, %ebx
movl $0x3, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x460c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x8707
testq %r14, %r14
je 0xaeed
movl 0x20044(%rbx), %eax
movl %eax, (%r14)
movq 0x20050(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x8707
cmpl $0x0, 0x2035c(%r14)
je 0xaff8
movl 0x20368(%r14), %eax
cvtsi2sd %rax, %xmm2
movsd 0x5773(%rip), %xmm0     # 0x106a0
addsd %xmm0, %xmm2
movsd 0x20020(%r14), %xmm3
mulsd %xmm3, %xmm2
subsd 0x20038(%r14), %xmm2
movsd 0x20360(%r14), %xmm4
xorpd %xmm5, %xmm5
unpcklps %xmm5, %xmm4            # xmm4 = xmm4[0],xmm5[0],xmm4[1],xmm5[1]
movapd 0x5791(%rip), %xmm1     # 0x106f0
orpd %xmm1, %xmm4
subpd %xmm1, %xmm4
movapd 0x5791(%rip), %xmm6     # 0x10700
addpd %xmm6, %xmm4
movupd 0x20028(%r14), %xmm7
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd %xmm4, %xmm3
subpd %xmm7, %xmm3
movupd %xmm3, (%rbx)
movsd %xmm2, 0x10(%rbx)
movl 0x20374(%r14), %eax
xorps %xmm2, %xmm2
cvtsi2sd %rax, %xmm2
addsd %xmm0, %xmm2
movsd 0x20020(%r14), %xmm0
mulsd %xmm0, %xmm2
subsd 0x20038(%r14), %xmm2
movsd 0x2036c(%r14), %xmm3
unpcklps %xmm5, %xmm3            # xmm3 = xmm3[0],xmm5[0],xmm3[1],xmm5[1]
orpd %xmm1, %xmm3
subpd %xmm1, %xmm3
addpd %xmm6, %xmm3
movupd 0x20028(%r14), %xmm1
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm3, %xmm0
subpd %xmm1, %xmm0
movupd %xmm0, 0x18(%rbx)
movsd %xmm2, 0x28(%rbx)
movl $0x1, %eax
jmp 0xaffa
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x358, %edi            # imm = 0x358
movl $0x1, %esi
callq 0x2d20
movq %rax, %r14
movl $0x3, 0xc(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xab08
movzwl 0x34(%rbx), %eax
movl %eax, 0x50(%r14)
leaq 0x54(%r14), %r15
movzwl 0x36(%rbx), %eax
movw %ax, 0x351(%r14)
movb 0x38(%rbx), %al
movb %al, 0x353(%r14)
leaq 0x39(%rbx), %rsi
movl $0x2fd, %edx            # imm = 0x2FD
movq %r15, %rdi
callq 0x2230
leaq 0x2005c(%rbx), %rdi
movl $0x300, %edx            # imm = 0x300
movq %r15, %rsi
callq 0x2230
movl $0x1, 0x20058(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rurban[P]dgnlib/dgnwrite.cpp
// Function: DGNWriteBounds(DGNInfo*, DGNElemCore*, DGNPoint*, DGNPoint*)
static void DGNWriteBounds( DGNInfo *psInfo, DGNElemCore *psElement,
                            DGNPoint *psMin, DGNPoint *psMax )

{
    CPLAssert( psElement->raw_bytes >= 28 );

    DGNInverseTransformPointToInt( psInfo, psMin, psElement->raw_data + 4 );
    DGNInverseTransformPointToInt( psInfo, psMax, psElement->raw_data + 16 );

    /* convert from twos complement to "binary offset" format. */

    psElement->raw_data[5] ^= 0x80;
    psElement->raw_data[9] ^= 0x80;
    psElement->raw_data[13] ^= 0x80;
    psElement->raw_data[17] ^= 0x80;
    psElement->raw_data[21] ^= 0x80;
    psElement->raw_data[25] ^= 0x80;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x48(%rsi), %rax
addq $0x4, %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0xadbc
movq 0x48(%r14), %rdx
addq $0x10, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xadbc
movq 0x48(%r14), %rax
xorb $-0x80, 0x5(%rax)
movq 0x48(%r14), %rax
xorb $-0x80, 0x9(%rax)
movq 0x48(%r14), %rax
xorb $-0x80, 0xd(%rax)
movq 0x48(%r14), %rax
xorb $-0x80, 0x11(%rax)
movq 0x48(%r14), %rax
xorb $-0x80, 0x15(%rax)
movq 0x48(%r14), %rax
xorb $-0x80, 0x19(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rurban[P]dgnlib/dgnwrite.cpp
// Function: DGNCreateColorTableElem
DGNElemCore *
DGNCreateColorTableElem( DGNHandle hDGN, int nScreenFlag, 
                         GByte abyColorInfo[256][3] )

{
    DGNElemColorTable *psCT;
    DGNElemCore *psCore;

/* -------------------------------------------------------------------- */
/*      Allocate element.                                               */
/* -------------------------------------------------------------------- */
    psCT = (DGNElemColorTable *) CPLCalloc( sizeof(DGNElemColorTable), 1 );
    psCore = &(psCT->core);

    DGNInitializeElemCore( hDGN, psCore );
    psCore->stype = DGNST_COLORTABLE;
    psCore->type = DGNT_GROUP_DATA;
    psCore->level = DGN_GDL_COLOR_TABLE;

/* -------------------------------------------------------------------- */
/*      Set colortable specific information in the structure.           */
/* -------------------------------------------------------------------- */
    psCT->screen_flag = nScreenFlag;
    memcpy( psCT->color_info, abyColorInfo, 768 );

/* -------------------------------------------------------------------- */
/*      Setup Raw data for the color table specific portion.            */
/* -------------------------------------------------------------------- */
    psCore->raw_bytes = 806;
    psCore->raw_data = (unsigned char*) CPLCalloc(psCore->raw_bytes,1);

    psCore->raw_data[36] = (unsigned char) (nScreenFlag % 256);
    psCore->raw_data[37] = (unsigned char) (nScreenFlag / 256);

    memcpy( psCore->raw_data + 38, abyColorInfo[255], 3 );
    memcpy( psCore->raw_data + 41, abyColorInfo, 783 );
    
/* -------------------------------------------------------------------- */
/*      Set the core raw data.                                          */
/* -------------------------------------------------------------------- */
    DGNUpdateElemCoreExtended( hDGN, psCore );
    
    return psCore;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %r15d
movl $0x358, %edi            # imm = 0x358
movl $0x1, %esi
callq 0x2d20
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movaps 0x37b7(%rip), %xmm0     # 0x10a00
movups %xmm0, 0x8(%rax)
movl %r15d, 0x50(%rax)
leaq 0x54(%rax), %rdi
movl $0x300, %edx            # imm = 0x300
movq %rbx, %rsi
callq 0x2230
movl $0x326, 0x40(%r14)      # imm = 0x326
movl $0x326, %edi            # imm = 0x326
movl $0x1, %esi
callq 0x2d20
movq %rax, 0x48(%r14)
movb %r15b, 0x24(%rax)
leal 0xff(%r15), %eax
testl %r15d, %r15d
cmovnsl %r15d, %eax
movq 0x48(%r14), %rcx
movb %ah, 0x25(%rcx)
movq 0x48(%r14), %rax
movzwl 0x2fd(%rbx), %ecx
movw %cx, 0x26(%rax)
movb 0x2ff(%rbx), %cl
movb %cl, 0x28(%rax)
movq 0x48(%r14), %rdi
addq $0x29, %rdi
movl $0x30f, %edx            # imm = 0x30F
movq %rbx, %rsi
callq 0x2230
movq %r14, %rsi
callq 0xbf25
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rurban[P]dgnlib/dgnwrite.cpp
// Function: DGNPointToInt(DGNInfo*, DGNPoint*, unsigned char*)
static void DGNPointToInt( DGNInfo *psDGN, DGNPoint *psPoint, 
                           unsigned char *pabyTarget )

{
    double     adfCT[4];
    int        i;

    adfCT[0] = psPoint->x;
    adfCT[1] = psPoint->y;
    adfCT[2] = psPoint->z;
    adfCT[3] = 0;
    assert(psDGN->dimension < 3);

    for( i = 0; i < psDGN->dimension; i++ )
    {
        GInt32 nCTI;
        unsigned char *pabyCTI = (unsigned char *) &nCTI;

        nCTI = (GInt32) MAX(-2147483647,MIN(2147483647,adfCT[i]));
        
#ifdef WORDS_BIGENDIAN 
        pabyTarget[i*4+0] = pabyCTI[1];
        pabyTarget[i*4+1] = pabyCTI[0];
        pabyTarget[i*4+2] = pabyCTI[3];
        pabyTarget[i*4+3] = pabyCTI[2];
#else
        pabyTarget[i*4+3] = pabyCTI[1];
        pabyTarget[i*4+2] = pabyCTI[0];
        pabyTarget[i*4+1] = pabyCTI[3];
        pabyTarget[i*4+0] = pabyCTI[2];
#endif        
    }
}

// Assembly:
subq $0x28, %rsp
movups (%rsi), %xmm0
movaps %xmm0, (%rsp)
movsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movl 0x20018(%rdi), %eax
cmpl $0x2, %eax
jg 0xdd43
testl %eax, %eax
jle 0xdd3e
xorl %eax, %eax
movsd 0x1f4e(%rip), %xmm0     # 0xfc28
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movsd 0x29e1(%rip), %xmm1     # 0x106c8
movsd (%rsp,%rax,8), %xmm2
xorl %esi, %esi
ucomisd %xmm0, %xmm2
setbe %sil
addl %esi, %esi
addl %ecx, %esi
ucomisd %xmm2, %xmm1
cmovbel %ecx, %esi
ucomisd %xmm0, %xmm2
cvttsd2si %xmm2, %r8d
cmoval %esi, %r8d
ucomisd %xmm2, %xmm1
cmoval %esi, %r8d
movl %r8d, %esi
movw %r8w, 0x2(%rdx,%rax,4)
shrl $0x10, %r8d
shrl $0x18, %esi
movb %sil, 0x1(%rdx,%rax,4)
movb %r8b, (%rdx,%rax,4)
incq %rax
movslq 0x20018(%rdi), %rsi
cmpq %rsi, %rax
jl 0xdce7
addq $0x28, %rsp
retq
leaq 0x2fbc(%rip), %rdi      # 0x10d06
leaq 0x2fca(%rip), %rsi      # 0x10d1b
leaq 0x2fd0(%rip), %rcx      # 0x10d28
movl $0x8a7, %edx            # imm = 0x8A7
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/rurban[P]dgnlib/dgnwrite.cpp
// Function: DGNAddMSLink
int DGNAddMSLink( DGNHandle hDGN, DGNElemCore *psElement, 
                  int nLinkageType, int nEntityNum, int nMSLink )

{
    unsigned char abyLinkage[32];
    int           nLinkageSize;

    if( nLinkageType == DGNLT_DMRS )
    {
        nLinkageSize = 8;
        abyLinkage[0] = 0x00;
        abyLinkage[1] = 0x00;
        abyLinkage[2] = (GByte) (nEntityNum % 256);
        abyLinkage[3] = (GByte) (nEntityNum / 256);
        abyLinkage[4] = (GByte) (nMSLink % 256);
        abyLinkage[5] = (GByte) ((nMSLink / 256) % 256);
        abyLinkage[6] = (GByte) (nMSLink / 65536);
        abyLinkage[7] = 0x01;
    }
    else
    {
        nLinkageSize = 16;
        abyLinkage[0] = 0x07;
        abyLinkage[1] = 0x10;
        abyLinkage[2] = (GByte) (nLinkageType % 256);
        abyLinkage[3] = (GByte) (nLinkageType / 256);
        abyLinkage[4] = (GByte) (0x81);
        abyLinkage[5] = (GByte) (0x0F);
        abyLinkage[6] = (GByte) (nEntityNum % 256);
        abyLinkage[7] = (GByte) (nEntityNum / 256);
        abyLinkage[8] = (GByte) (nMSLink % 256);
        abyLinkage[9] = (GByte) ((nMSLink / 256) % 256);
        abyLinkage[10] = (GByte) ((nMSLink / 65536) % 256);
        abyLinkage[11] = (GByte) (nMSLink / 16777216);
        abyLinkage[12] = 0x00;
        abyLinkage[13] = 0x00;
        abyLinkage[14] = 0x00;
        abyLinkage[15] = 0x00;
    }

    return DGNAddRawAttrLink( hDGN, psElement, nLinkageSize, abyLinkage );
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
testl %edx, %edx
je 0xe007
movw $0x1007, (%rsp)         # imm = 0x1007
movb %dl, 0x2(%rsp)
movl $0xff, %eax
leal (%rdx,%rax), %ebx
testl %edx, %edx
cmovnsl %edx, %ebx
movb %bh, 0x3(%rsp)
movw $0xf81, 0x4(%rsp)       # imm = 0xF81
leal (%rcx,%rax), %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
movb %cl, 0x6(%rsp)
movb %dh, 0x7(%rsp)
movb %r8b, 0x8(%rsp)
addl %r8d, %eax
leal 0xffff(%r8), %ecx
testl %r8d, %r8d
cmovnsl %r8d, %eax
leal 0xffffff(%r8), %edx
movb %ah, 0x9(%rsp)
cmovnsl %r8d, %ecx
cmovnsl %r8d, %edx
shrl $0x10, %ecx
movb %cl, 0xa(%rsp)
shrl $0x18, %edx
movb %dl, 0xb(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x10, %edx
jmp 0xe051
movw $0x0, (%rsp)
movb %cl, 0x2(%rsp)
movl $0xff, %eax
leal (%rcx,%rax), %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
movb %dh, 0x3(%rsp)
movb %r8b, 0x4(%rsp)
addl %r8d, %eax
testl %r8d, %r8d
cmovnsl %r8d, %eax
leal 0xffff(%r8), %ecx
movb %ah, 0x5(%rsp)
cmovnsl %r8d, %ecx
shrl $0x10, %ecx
movb %cl, 0x6(%rsp)
movb $0x1, 0x7(%rsp)
movl $0x8, %edx
movq %rsp, %rcx
callq 0xd3d4
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/rurban[P]dgnlib/dgnopen.cpp
// Function: DGNTestOpen
int DGNTestOpen( GByte *pabyHeader, int nByteCount )

{
    if( nByteCount < 4 )
        return TRUE;

    // Is it a cell library?
    if( pabyHeader[0] == 0x08
        && pabyHeader[1] == 0x05
        && pabyHeader[2] == 0x17
        && pabyHeader[3] == 0x00 )
        return TRUE;

    // Is it not a regular 2D or 3D file?
    if( (pabyHeader[0] != 0x08 && pabyHeader[0] != 0xC8) 
        || pabyHeader[1] != 0x09
        || pabyHeader[2] != 0xFE || pabyHeader[3] != 0x02 )
        return FALSE;

    return TRUE;
}

// Assembly:
movl $0x1, %eax
cmpl $0x4, %esi
jl 0xe0d5
movzbl (%rdi), %ecx
cmpl $0x8, %ecx
je 0xe0a3
cmpl $0xc8, %ecx
jne 0xe0d3
movb 0x1(%rdi), %cl
jmp 0xe0b9
movb 0x1(%rdi), %cl
cmpb $0x5, %cl
jne 0xe0b9
cmpb $0x17, 0x2(%rdi)
jne 0xe0d3
cmpb $0x0, 0x3(%rdi)
jne 0xe0d3
jmp 0xe0d5
cmpb $0x9, %cl
jne 0xe0d3
cmpb $-0x2, 0x2(%rdi)
movl $0x0, %eax
jne 0xe0d5
xorl %eax, %eax
cmpb $0x2, 0x3(%rdi)
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/rurban[P]dgnlib/dgnopen.cpp
// Function: DGNSpatialFilterToUOR(DGNInfo*)
void DGNSpatialFilterToUOR( DGNInfo *psDGN )

{
    DGNPoint    sMin, sMax;

    if( psDGN->sf_converted_to_uor 
        || !psDGN->has_spatial_filter 
        || !psDGN->got_tcb )
        return;

    sMin.x = psDGN->sf_min_x_geo;
    sMin.y = psDGN->sf_min_y_geo;
    sMin.z = 0;
    
    sMax.x = psDGN->sf_max_x_geo;
    sMax.y = psDGN->sf_max_y_geo;
    sMax.z = 0;

    DGNInverseTransformPoint( psDGN, &sMin );
    DGNInverseTransformPoint( psDGN, &sMax );

    psDGN->sf_min_x = (GUInt32) (sMin.x + 2147483648.0);
    psDGN->sf_min_y = (GUInt32) (sMin.y + 2147483648.0);
    psDGN->sf_max_x = (GUInt32) (sMax.x + 2147483648.0);
    psDGN->sf_max_y = (GUInt32) (sMax.y + 2147483648.0);

    psDGN->sf_converted_to_uor = TRUE;
}

// Assembly:
cmpl $0x0, 0x2037c(%rdi)
je 0xe2b7
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x20378(%rdi)
je 0xe385
cmpl $0x0, 0x20014(%rbx)
je 0xe385
movups 0x20398(%rbx), %xmm0
leaq 0x20(%rsp), %r14
movaps %xmm0, (%r14)
xorl %eax, %eax
movq %rax, 0x10(%r14)
movups 0x203a8(%rbx), %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
movq %rax, 0x10(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xace4
movq %rbx, %rdi
movq %r15, %rsi
callq 0xace4
movapd 0x2a4d(%rip), %xmm0     # 0x10d70
movapd (%r14), %xmm1
movapd (%r15), %xmm2
addpd %xmm0, %xmm2
cvttpd2dq %xmm2, %xmm3
addpd %xmm0, %xmm1
subpd %xmm0, %xmm2
cvttpd2dq %xmm2, %xmm2
movapd %xmm3, %xmm4
psrad $0x1f, %xmm4
cvttpd2dq %xmm1, %xmm5
pand %xmm2, %xmm4
subpd %xmm0, %xmm1
cvttpd2dq %xmm1, %xmm0
por %xmm3, %xmm4
movapd %xmm5, %xmm1
psrad $0x1f, %xmm1
pand %xmm0, %xmm1
por %xmm5, %xmm1
punpcklqdq %xmm4, %xmm1    # xmm1 = xmm1[0],xmm4[0]
movdqu %xmm1, 0x20388(%rbx)
movl $0x1, 0x2037c(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/yahoo[P]UDPing/src/options.cc
// Function: Options::Options(int, char**, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Options::Options (int argc, char** argv, string optstring) {
    memset (options, 0, 256 * sizeof(char*));
    int opt;
    while (1) {
        optarg = 0;
        opt = getopt(argc, argv, optstring.c_str());
        if (opt < 0) {
            break;
        } else if (opt == '?') {
            exit(-1);
        }
        if (optarg) {
            options[opt] = new char[strlen(optarg) + 1];
            strcpy(options[opt], optarg);
        } else {
            options[opt] = (char*)1;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl $0x800, %edx            # imm = 0x800
xorl %esi, %esi
callq 0x2190
movq 0x4783(%rip), %r12      # 0x7fc0
movq $0x0, (%r12)
movq (%rbx), %rdx
movl %ebp, %edi
movq %r14, %rsi
callq 0x20c0
testl %eax, %eax
js 0x3891
cmpl $0x3f, %eax
je 0x38a0
movq (%r12), %rdi
movl %eax, %r13d
testq %rdi, %rdi
je 0x3887
callq 0x2140
leaq 0x1(%rax), %rdi
callq 0x2030
movq %rax, (%r15,%r13,8)
movq (%r12), %rsi
movq %rax, %rdi
callq 0x2270
jmp 0x383d
movq $0x1, (%r15,%r13,8)
jmp 0x383d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/yahoo[P]UDPing/src/options.cc
// Function: Options::parseIntOption(char, int, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Options::parseIntOption (char index, int required, int min, int max, string usage, string error) {
    int ret = 0;
    if (options[index]) {
        ret = atoi(options[index]);
        if ((ret < min) || (ret > max)) {
            cerr << usage << error;
            exit (-1);
        }
    } else {
        if (required) {
            cerr << usage << error;
            exit (-1);
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %r14
movq 0x30(%rsp), %rbx
movslq %esi, %rax
movq (%rdi,%rax,8), %rdi
testq %rdi, %rdi
je 0x38e4
movl %r8d, %ebp
movl %ecx, %r15d
callq 0x23a0
cmpl %r15d, %eax
jl 0x38ea
cmpl %ebp, %eax
jg 0x38ea
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
testl %edx, %edx
je 0x38d9
movq 0x46ff(%rip), %rdi      # 0x7ff0
movq %r14, %rsi
callq 0x2230
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2230
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/yahoo[P]UDPing/src/options.cc
// Function: Options::getStringOption(char, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
char* Options::getStringOption (char index, int required, string usage, string error) {
    char* ret = 0;
    if (options[index] > (char*)1) {
        ret = options[index];
    } else {
        if (required) {
            cerr << usage << error;
            exit (-1);
        }
    }
    return ret;
}

// Assembly:
movslq %esi, %rax
movq (%rdi,%rax,8), %rax
cmpq $0x1, %rax
ja 0x3921
testl %edx, %edx
jne 0x3922
xorl %eax, %eax
retq
pushq %rbx
movq %r8, %rbx
movq 0x46c3(%rip), %rdi      # 0x7ff0
movq %rcx, %rsi
callq 0x2230
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2230
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/yahoo[P]UDPing/src/delay.cc
// Function: doRandomPause(timespec*, int)
void doRandomPause (struct timespec* timer, int avgDelayMS) {
    double desiredTimeNS = log((double)rand()/RAND_MAX) * -(avgDelayMS * 1000000);
    desiredTimeNS -= checkTimer(timer);
    /* limit the delay */
    if (desiredTimeNS > ((long)avgDelayMS * 1000000 * 10)) {
        desiredTimeNS = ((long)avgDelayMS * 1000000 * 10);
    }
    if (desiredTimeNS <= 0) {
        return;
    }
    /*printf ("Sleeping for %f ns\n", desiredTimeNS);*/
    struct timespec delay;
    struct timespec remaining;
    delay.tv_sec = desiredTimeNS/1000000000l;
    delay.tv_nsec = (desiredTimeNS - (delay.tv_sec * 1000000000l));
    while (nanosleep(&delay, &remaining)) {
        if (errno == EINTR) {
            memcpy (&delay, &remaining, sizeof(delay));
        } else {
            warn ("Nanosleep error");
            break;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movq %rdi, %r14
callq 0x20e0
cvtsi2sd %eax, %xmm0
divsd 0x1c9a(%rip), %xmm0     # 0x5680
callq 0x21e0
imull $0xfff0bdc0, %ebx, %eax # imm = 0xFFF0BDC0
cvtsi2sd %eax, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rsp)
movq %rsp, %r15
xorl %edi, %edi
movq %r15, %rsi
callq 0x2250
movq (%r15), %rax
subq (%r14), %rax
movq 0x8(%r15), %rcx
imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00
subq 0x8(%r14), %rcx
addq %rax, %rcx
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
movsd 0x18(%rsp), %xmm1
subsd %xmm0, %xmm1
movslq %ebx, %rax
imulq $0x989680, %rax, %rax   # imm = 0x989680
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
minsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x3ada
movapd %xmm0, %xmm1
divsd 0x1c22(%rip), %xmm1     # 0x5688
cvttsd2si %xmm1, %rax
movq %rsp, %rdi
movq %rax, (%rdi)
imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, 0x8(%rdi)
leaq 0x20(%rsp), %rsi
callq 0x20f0
testl %eax, %eax
je 0x3ada
callq 0x2050
movq %rax, %rbx
movq %rsp, %r14
leaq 0x20(%rsp), %r15
cmpl $0x4, (%rbx)
jne 0x3acc
movupd 0x20(%rsp), %xmm0
movapd %xmm0, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x20f0
testl %eax, %eax
jne 0x3aab
jmp 0x3ada
leaq 0x1bbd(%rip), %rdi      # 0x5690
xorl %eax, %eax
callq 0x2100
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/yahoo[P]UDPing/src/delay.cc
// Function: setIntervalTimer(int, void (*)(int))
void setIntervalTimer (int keepalive, sighandler_t handler) {
    struct itimerval it;
    signal (SIGALRM, handler);
    memset (&it, 0, sizeof (struct itimerval));
    it.it_interval.tv_sec = keepalive;
    it.it_interval.tv_usec = 0;
    it.it_value.tv_sec = keepalive;
    it.it_value.tv_usec = 0;
    if (setitimer(ITIMER_REAL, &it, (struct itimerval*)0)) {
         err(1, "Setitimer failed");
    }
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl %edi, %ebx
movl $0xe, %edi
callq 0x2300
movslq %ebx, %rax
movq %rsp, %rsi
movq %rax, (%rsi)
xorl %ecx, %ecx
movq %rcx, 0x8(%rsi)
movq %rax, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
xorl %edi, %edi
xorl %edx, %edx
callq 0x2380
testl %eax, %eax
jne 0x3b1f
addq $0x20, %rsp
popq %rbx
retq
leaq 0x1b7a(%rip), %rsi      # 0x56a0
movl $0x1, %edi
xorl %eax, %eax
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O3/yahoo[P]UDPing/src/protocol.cc
// Function: getSockAddr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
struct sockaddr* getSockAddr (string host, int port) {
    int s;
    struct sockaddr* ret = 0;
    struct addrinfo hints;
    struct addrinfo* addrinfo;
    char portString[100];

    memset (&hints, 0, sizeof(struct addrinfo));
    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_DGRAM;
    hints.ai_flags = AI_PASSIVE;

    snprintf (portString, 100, "%d", port);

    if (s = getaddrinfo (host.c_str(), portString, &hints, &addrinfo)) {
        err(1, "getaddrinfo: %s\n", gai_strerror(s));
    } else {
        ret = new struct sockaddr;
        memcpy (ret, addrinfo->ai_addr, sizeof(ret));
    }
    freeaddrinfo(addrinfo);
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movl %esi, %ecx
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movups %xmm0, 0x8(%r14)
movups %xmm0, 0x18(%r14)
movq $0x0, 0x28(%r14)
movl $0x2, 0x8(%r14)
movabsq $0x200000001, %rax      # imm = 0x200000001
movq %rax, (%r14)
leaq 0x19ff(%rip), %rdx      # 0x56ff
leaq 0x40(%rsp), %r15
movl $0x64, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x23c0
movq (%rbx), %rdi
leaq 0x8(%rsp), %rcx
movq %r15, %rsi
movq %r14, %rdx
callq 0x2330
testl %eax, %eax
jne 0x3d5c
movl $0x10, %edi
callq 0x22d0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
movq 0x18(%rdi), %rax
movq (%rax), %rax
movq %rax, (%rbx)
callq 0x2340
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x2350
leaq 0x1974(%rip), %rsi      # 0x56de
movl $0x1, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/yahoo[P]UDPing/src/protocol.cc
// Function: sendMessage(int, int, unsigned char*, unsigned int, int, unsigned char*, unsigned int, int, char const*, int, int)
int sendMessage(
                int socketFD, 
                int ifIndex,
                uint8_t *srcMacHex,
                uint32_t srcIp,
                int srcPort,
                uint8_t *dstMacHex,
                uint32_t dstIp,
                int dstPort,
                const char* message,
                int datalen,
                int checksumLength) {
    struct sockaddr_ll device;
//    printf ("Sending message <<%s>>\n", message);
    struct frame outboundFrame;
    int frameLength;

    memset (&device, 0, sizeof (device));
    device.sll_ifindex = ifIndex;
    device.sll_family = AF_PACKET;
    memcpy (device.sll_addr, srcMacHex, 6);
    device.sll_halen = 6;

    frameLength = buildFrame(&outboundFrame, srcMacHex, dstMacHex, srcIp, dstIp, srcPort, dstPort, message, datalen, checksumLength);

    uint8_t* frameBuf = (uint8_t*) &outboundFrame;

//    printf ("Packet Dump:\n");
//    for (int ix = 0; ix < frameLength; ix ++) {
//        printf("%02x ", frameBuf[ix]);
//        if (!((ix + 1) % 4)) {
//            printf ("\n");
//        }
//    }
//    printf ("\n\n");

    int bytes = sendto(socketFD, frameBuf, frameLength, 0, (struct sockaddr *) &device, sizeof (device));
    if (bytes != frameLength) {
        perror ("sendto failed");
    }

//    printf ("sendto sent %d of %d bytes!\n", bytes, frameLength);
    return datalen;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10040, %rsp          # imm = 0x10040
movl %r8d, %eax
movl %edi, %ebp
movl 0x10088(%rsp), %ebx
movl 0x10070(%rsp), %r8d
movl 0x10078(%rsp), %r10d
movq 0x10080(%rsp), %r11
movl 0x10090(%rsp), %r12d
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movl $0x0, 0x10(%r14)
movl %esi, 0x4(%r14)
movw $0x11, (%r14)
movzwl 0x4(%rdx), %esi
movw %si, 0x10(%r14)
movl (%rdx), %esi
movl %esi, 0xc(%r14)
movb $0x6, 0xb(%r14)
leaq 0x17(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
movq %r9, %rdx
movl %eax, %r9d
pushq %r12
pushq %rbx
pushq %r11
pushq %r10
callq 0x3e45
addq $0x20, %rsp
movslq %eax, %r12
movl %ebp, %edi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
movq %r14, %r8
movl $0x14, %r9d
callq 0x2070
cmpl %eax, %r12d
jne 0x3e37
movl %ebx, %eax
addq $0x10040, %rsp          # imm = 0x10040
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18c4(%rip), %rdi      # 0x5702
callq 0x2210
jmp 0x3e25
// File: /workspace/github_cpp_makefile_star2_O3/yahoo[P]UDPing/src/protocol.cc
// Function: checksum(unsigned short*, int)
uint16_t checksum (uint16_t *addr, int len)
{
  int count = len;
  register uint32_t sum = 0;
  uint16_t answer = 0;

  // Sum up 2-byte values until none or only one byte left.
  while (count > 1) {
    sum += *(addr++);
    count -= 2;
  }

  // Add left-over byte, if any.
  if (count > 0) {
    sum += *(uint8_t *) addr;
  }

  // Fold 32-bit sum into 16 bits; we lose information by doing this,
  // increasing the chances of a collision.
  // sum = (lower 16 bits) + (upper 16 bits shifted right 16 bits)
  while (sum >> 16) {
    sum = (sum & 0xffff) + (sum >> 16);
  }

  // Checksum is one's compliment of sum.
  answer = ~sum;

  return (answer);
}

// Assembly:
xorl %eax, %eax
cmpl $0x2, %esi
jl 0x3f89
xorl %eax, %eax
movzwl (%rdi), %ecx
addq $0x2, %rdi
addl %ecx, %eax
leal -0x2(%rsi), %ecx
cmpl $0x3, %esi
movl %ecx, %esi
ja 0x3f74
jmp 0x3f8b
movl %esi, %ecx
cmpl $0x1, %ecx
jne 0x3f95
movzbl (%rdi), %ecx
addl %ecx, %eax
cmpl $0x10000, %eax          # imm = 0x10000
jb 0x3fae
movl $0xffff, %ecx           # imm = 0xFFFF
movl %eax, %edx
shrl $0x10, %edx
andl %ecx, %eax
addl %edx, %eax
cmpl %ecx, %eax
ja 0x3fa1
notl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/yahoo[P]UDPing/src/protocol.cc
// Function: udp4_checksum2(ip, udphdr, unsigned short*, int)
uint16_t udp4_checksum2 (struct ip iphdr, struct udphdr udphdr, uint16_t *payload, int payloadlen)
{
    register uint32_t sum = 0;

    sum += (iphdr.ip_src.s_addr & 0xffff);
    sum += (iphdr.ip_src.s_addr >> 16);
    sum += (iphdr.ip_dst.s_addr & 0xffff);
    sum += (iphdr.ip_dst.s_addr >> 16);
    uint16_t tmp = iphdr.ip_p;
    tmp = tmp << 8;
    sum += tmp;
    sum += udphdr.len;
    sum += udphdr.source;
    sum += udphdr.dest;
    sum += udphdr.len;
    while (payloadlen > 1) {
        sum += *(payload++);
        payloadlen -= 2;
    }
    if (payloadlen == 1) {
        uint16_t tmp = *((uint8_t *)payload);
        tmp = tmp << 8;
        sum += tmp;
    }
    while (sum >> 16) {
        sum = (sum & 0xffff) + (sum >> 16);
    }
    return ~sum;
}

// Assembly:
movq %rdi, %rax
movl %eax, %ecx
shrl $0x10, %ecx
movl 0x14(%rsp), %edi
movl 0x18(%rsp), %r8d
movl $0xffff, %r9d           # imm = 0xFFFF
movl %edi, %r10d
andl %r9d, %r10d
shrl $0x10, %edi
movl %r8d, %r11d
andl %r9d, %r11d
addl %r10d, %r11d
shrl $0x10, %r8d
movzbl 0x11(%rsp), %r10d
shll $0x8, %r10d
addl %r8d, %r10d
andl %eax, %r9d
addl %ecx, %r9d
shrq $0x1f, %rax
andl $0x1fffe, %eax          # imm = 0x1FFFE
addl %r9d, %eax
addl %edi, %eax
addl %r11d, %eax
addl %r10d, %eax
cmpl $0x2, %edx
jl 0x401f
movzwl (%rsi), %ecx
addq $0x2, %rsi
addl %ecx, %eax
leal -0x2(%rdx), %ecx
cmpl $0x3, %edx
movl %ecx, %edx
ja 0x400a
jmp 0x4021
movl %edx, %ecx
cmpl $0x1, %ecx
jne 0x4030
movzbl (%rsi), %ecx
shll $0x8, %ecx
addl %eax, %ecx
movl %ecx, %eax
cmpl $0x10000, %eax          # imm = 0x10000
jb 0x4049
movl $0xffff, %ecx           # imm = 0xFFFF
movl %eax, %edx
shrl $0x10, %edx
andl %ecx, %eax
addl %edx, %eax
cmpl %ecx, %eax
ja 0x403c
notl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/yahoo[P]UDPing/src/clientsession.cc
// Function: isValidPort(int)
int isValidPort(int port) {
    if (port < MIN_PORT) {
        cerr << "Port too low: " << port << endl;
        exit(-1);
    }
    if (port > MAX_PORT) {
        cerr << "Port too high: " << port << endl;
        exit(-1);
    }
    return 1;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
cmpl $0x3ff, %edi            # imm = 0x3FF
jle 0x4066
cmpl $0xea61, %ebx           # imm = 0xEA61
jae 0x4076
movl $0x1, %eax
popq %rbx
retq
movq 0x3f83(%rip), %rdi      # 0x7ff0
leaq 0x169c(%rip), %rsi      # 0x5710
jmp 0x4084
movq 0x3f73(%rip), %rdi      # 0x7ff0
leaq 0x169b(%rip), %rsi      # 0x571f
callq 0x22c0
movq %rax, %rdi
movl %ebx, %esi
callq 0x23e0
movq %rax, %rdi
callq 0x2160
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/yahoo[P]UDPing/src/clientsession.cc
// Function: ClientSessionList::~ClientSessionList()
ClientSessionList::~ClientSessionList () {
    for (curSession = sessions.begin(); curSession != sessions.end(); curSession++) {
        delete *curSession;
    }
    delete srcAddr;
    delete dstAddr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movq 0x8(%rdi), %rax
movq %rax, 0x20(%rdi)
cmpq %r15, %rax
je 0x45eb
movq 0x10(%rax), %r14
testq %r14, %r14
je 0x45d6
leaq 0x828(%r14), %rdi
callq 0x4a72
movq %r14, %rdi
callq 0x2280
movq 0x20(%rbx), %rax
movq (%rax), %rax
movq %rax, 0x20(%rbx)
jmp 0x45bc
movq 0x28(%rbx), %rdi
callq 0x2280
movq 0x30(%rbx), %rdi
callq 0x2280
movq 0x8(%rbx), %rdi
cmpq %r15, %rdi
je 0x4616
movq (%rdi), %rbx
callq 0x2280
movq %rbx, %rdi
cmpq %r15, %rbx
jne 0x4606
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/yahoo[P]UDPing/src/clientsession.cc
// Function: ClientSession::ClientSession(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ClientSessionList*)
ClientSession::ClientSession(int port, string dstMacs, ClientSessionList* parent) :
    dstMacList(dstMacs)
{
    this->port = port;
    this->parent = parent;
    lastRollover = 0;
    memset (&p, 0, sizeof(paddedPacket));
    p.header.protoVersion = PROTOVERSION;
    p.header.clientStartTime = time(0);
    p.header.seqNum = 0;
    reset();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x828(%rdi), %r15
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x36e6
movq %r15, %rdi
movq %r12, %rsi
callq 0x4910
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x46e1
callq 0x2280
movl %ebp, 0x818(%rbx)
movq %r14, 0x838(%rbx)
movq $0x0, 0x820(%rbx)
movl $0x818, %edx            # imm = 0x818
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2190
movb $0x1, (%rbx)
xorl %edi, %edi
callq 0x2260
movq %rax, 0x8(%rbx)
movl $0x0, 0x28(%rbx)
movq $-0x14, %r14
leaq 0x10d6(%rip), %r15      # 0x5801
callq 0x20e0
leal 0xf(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
andl $-0x10, %ecx
subl %ecx, %eax
cltq
movb (%rax,%r15), %al
movb %al, 0x24(%rbx,%r14)
incq %r14
jne 0x472b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x476e
callq 0x2280
movq %rbx, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O3/yahoo[P]UDPing/src/clientsession.cc
// Function: ClientSession::rollover()
bool ClientSession::rollover() {
    time_t curTime = time(0);
    curTime -= curTime % parent->getInterval();
    if (!lastRollover) {
        lastRollover = curTime;
    }
    if (curTime == lastRollover) {
        return false;
    }
    lastRollover = curTime;
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x2260
movq %rax, %rcx
movq 0x820(%rbx), %rsi
movq 0x838(%rbx), %rax
movslq 0x48(%rax), %rdi
movq %rcx, %rax
cqto
idivq %rdi
subq %rdx, %rcx
testq %rsi, %rsi
setne %al
je 0x47fe
cmpq %rsi, %rcx
je 0x4808
movq %rcx, 0x820(%rbx)
movl %eax, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yahoo[P]UDPing/src/maclist.cc
// Function: MacList::MacList(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
MacList::MacList (string macListString) {
    const char* mls = macListString.c_str();
    numMacs = 1;
    macs = 0;
    const char* nextString = mls;
    while ((nextString = strchr(nextString + 1, ',')) != 0) {
        numMacs++;
    }
    macs = new uint8_t *[numMacs];
    nextString = mls;
    for (curMac = 0; curMac < numMacs; curMac++) {
        macs[curMac] = new uint8_t[12];
        memset (macs[curMac], 0, 6);
        int numFields = sscanf(mls, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", 
                        &(macs[curMac][0]),
                        &(macs[curMac][1]),
                        &(macs[curMac][2]),
                        &(macs[curMac][3]),
                        &(macs[curMac][4]),
                        &(macs[curMac][5]));
        if (numFields < 6) {
            cerr << "Invalid MAC string: " << macListString << endl;
            numMacs = 0;
            return;
        };
        mls = strchr (mls, ',') + 1;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
movl $0x1, (%rdi)
movq $0x0, 0x8(%rdi)
leaq 0x1(%r15), %rdi
movl $0x2c, %esi
callq 0x2120
movl $0x8, %r12d
testq %rax, %rax
je 0x496a
movl $0x2, %ebp
movl %ebp, (%rbx)
incq %rax
movq %rax, %rdi
movl $0x2c, %esi
callq 0x2120
addq $0x8, %r12
incl %ebp
testq %rax, %rax
jne 0x494d
movq %r12, %rdi
callq 0x2030
movq %rax, 0x8(%rbx)
movl $0x0, 0x4(%rbx)
leaq 0xe8e(%rip), %r12       # 0x5812
xorl %ebp, %ebp
movl $0xc, %edi
callq 0x2030
movq 0x8(%rbx), %rcx
movslq %ebp, %rdx
movq %rax, (%rcx,%rdx,8)
movq 0x8(%rbx), %rax
movq (%rax,%rdx,8), %rax
movl $0x0, (%rax)
movw $0x0, 0x4(%rax)
movq 0x8(%rbx), %rax
movslq 0x4(%rbx), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x1(%rdx), %rcx
leaq 0x2(%rdx), %r8
leaq 0x3(%rdx), %r9
leaq 0x4(%rdx), %r10
leaq 0x5(%rdx), %r11
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x22b0
addq $0x10, %rsp
cmpl $0x5, %eax
jle 0x4a0e
movq %r15, %rdi
movl $0x2c, %esi
callq 0x2120
movq %rax, %r15
incq %r15
movl 0x4(%rbx), %ebp
incl %ebp
movl %ebp, 0x4(%rbx)
cmpl (%rbx), %ebp
jl 0x4986
jmp 0x4a68
movq 0x35db(%rip), %r15      # 0x7ff0
leaq 0xe14(%rip), %rsi       # 0x5830
movl $0x14, %edx
movq %r15, %rdi
callq 0x22e0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x22e0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x22a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x21a0
movl $0x0, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yahoo[P]UDPing/src/maclist.cc
// Function: MacList::~MacList()
MacList::~MacList () {
    if (!macs) {
        return;
    }
    for (curMac = 0; curMac < numMacs; curMac++) {
        delete macs[curMac];
    }
    delete macs;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x4ab2
movl $0x0, 0x4(%rbx)
cmpl $0x0, (%rbx)
jle 0x4aac
xorl %eax, %eax
movq 0x8(%rbx), %rcx
cltq
movq (%rcx,%rax,8), %rdi
callq 0x2280
movl 0x4(%rbx), %eax
incl %eax
movl %eax, 0x4(%rbx)
cmpl (%rbx), %eax
jl 0x4a8d
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x2280
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/CMU-SAFARI[P]optimal-seed-solver/basicSolver.cc
// Function: BasicSolver::solveDNA(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
unsigned int BasicSolver::solveDNA(string DNA) {
	assert(DNA.length() == readLength);

	unsigned int interval = readLength / seedNum;

	unsigned int totalFreq = 0;

	for (int i = 0; i < seedNum; i++) {
		string seed = DNA.substr(i * interval, seedLength);

		tree.query(seed);
		totalFreq += tree.frequency();
	}

	return totalFreq;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl 0x358(%rdi), %eax
movq %rsi, 0x40(%rsp)
cmpq %rax, 0x8(%rsi)
jne 0x46cb
movq %rdi, %r14
xorl %ebx, %ebx
xorl %edx, %edx
divl 0x35c(%rdi)
movl %eax, %ebp
movq %rsp, %r12
xorl %r13d, %r13d
movl %ebp, %edx
imull %ebx, %edx
movl 0x360(%r14), %ecx
leaq 0x20(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x3290
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x41dc
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x57b0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x467c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3280
movq %r14, %rdi
callq 0x5938
movl %eax, %r15d
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x46a3
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3280
addl %r15d, %r13d
incq %rbx
movl 0x35c(%r14), %eax
cmpq %rax, %rbx
jb 0x4618
movl %r13d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x49e9(%rip), %rdi      # 0x90bb
leaq 0x49fd(%rip), %rsi      # 0x90d6
leaq 0x4a05(%rip), %rcx      # 0x90e5
movl $0x16, %edx
callq 0x3190
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x470d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3280
jmp 0x470d
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x4729
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x3450
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/CMU-SAFARI[P]optimal-seed-solver/HashTree.cc
// Function: TreeNode::TreeNode(TreeNode const&)
TreeNode::TreeNode(const TreeNode& rhs) {
	if (A != NULL) {
		delete A;
		A = NULL;
	}
	if (C != NULL) {
		delete C;
		C = NULL;
	}
	if (G != NULL) {
		delete G;
		G = NULL;
	}
	if (T != NULL) {
		delete T;
		T = NULL;
	}

	if (rhs.A != NULL)
		A = new TreeNode(*rhs.A);
	if (rhs.C != NULL)
		C = new TreeNode(*rhs.C);
	if (rhs.C != NULL)
		G = new TreeNode(*rhs.G);
	if (rhs.T != NULL)
		T = new TreeNode(*rhs.T);

	this->locNum = rhs.locNum;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8587(%rip), %rax      # 0xcd08
movq %rax, (%rdi)
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x479b
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x18(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x47b2
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x20(%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x47c9
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x28(%rbx)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x47e0
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x30(%rbx)
movq 0x18(%r14), %r12
testq %r12, %r12
je 0x4805
movl $0x38, %edi
callq 0x3270
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x476c
movq %r15, 0x18(%rbx)
movq 0x20(%r14), %r12
testq %r12, %r12
je 0x484e
movl $0x38, %edi
callq 0x3270
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x476c
movq %r15, 0x20(%rbx)
cmpq $0x0, 0x20(%r14)
je 0x484e
movl $0x38, %edi
callq 0x3270
movq %rax, %r15
movq 0x28(%r14), %rsi
movq %rax, %rdi
callq 0x476c
movq %r15, 0x28(%rbx)
movq 0x30(%r14), %r12
testq %r12, %r12
je 0x4873
movl $0x38, %edi
callq 0x3270
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x476c
movq %r15, 0x30(%rbx)
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x488c
jmp 0x488c
jmp 0x488c
movq %rax, %rbx
movl $0x38, %esi
movq %r15, %rdi
callq 0x3280
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O3/CMU-SAFARI[P]optimal-seed-solver/HashTree.cc
// Function: TreeNode::deleteChildren()
void TreeNode::deleteChildren() {

	if (A != NULL) {
		delete A;
		A = NULL;
	}

	if (C != NULL) {
		delete C;
		C = NULL;
	}

	if (G != NULL) {
		delete G;
		G = NULL;
	}

	if (T != NULL) {
		delete T;
		T = NULL;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x48d5
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x18(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x48ec
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x20(%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x4903
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x28(%rbx)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x491a
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x30(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/CMU-SAFARI[P]optimal-seed-solver/HashTree.cc
// Function: LeafNode::LeafNode(unsigned int, unsigned int)
TreeNode::TreeNode() {
	locNum = 0;
	A = NULL;
	C = NULL;
	G = NULL;
	T = NULL;
}

// Assembly:
movl $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
leaq 0x8367(%rip), %rax      # 0xcd48
movq %rax, (%rdi)
movl %esi, 0x38(%rdi)
movl %edx, 0x3c(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/CMU-SAFARI[P]optimal-seed-solver/HashTree.cc
// Function: HashTree::HashTree(unsigned int, unsigned int)
HashTree::HashTree(unsigned int hashLength, unsigned int fullLength) {
	this->hashLength = hashLength;
	this->fullLength = fullLength;

	root = new TreeNode*[1 << (2 * hashLength)];

	for (int i = 0; i < 1 << (2 * hashLength); i++)
		root[i] = NULL;

	checkdb = NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
xorl %ecx, %ecx
movl %ecx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
leaq 0x40(%rdi), %rax
movl %ecx, 0x40(%rdi)
movq %rcx, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movq %rax, 0x58(%rdi)
movq %rcx, 0x60(%rdi)
leaq 0x70(%rdi), %rax
movl %ecx, 0x70(%rdi)
movq %rcx, 0x78(%rdi)
movq %rax, 0x80(%rdi)
movq %rax, 0x88(%rdi)
movq %rcx, 0x90(%rdi)
leaq 0xa8(%rdi), %r14
movq %r14, %rdi
callq 0x7f7c
leaq 0x318(%rbx), %r12
movq %r12, %rdi
callq 0x8b18
leaq 0x328(%rbx), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x328(%rbx)
movq $0x0, 0x338(%rbx)
movl %ebp, (%rbx)
movl %r15d, 0x4(%rbx)
addl %ebp, %ebp
movl $0x1, %r15d
movl %ebp, %ecx
shll %cl, %r15d
leaq (,%r15,8), %rdi
callq 0x3030
movq %rax, 0x320(%rbx)
xorl %eax, %eax
movq 0x320(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r15
jne 0x4b32
movq $0x0, 0x310(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r13, %rdi
callq 0x6e0e
movq %r12, %rdi
callq 0x8bb6
jmp 0x4b7b
movq %rax, %r15
movq %r14, %rdi
callq 0x7fda
jmp 0x4b88
movq %rax, %r15
leaq 0x68(%rbx), %rdi
leaq 0x38(%rbx), %r14
addq $0x8, %rbx
callq 0x7206
movq %r14, %rdi
callq 0x7256
movq %rbx, %rdi
callq 0x7256
movq %r15, %rdi
callq 0x3450
nop