LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: rurban[P]dgnlib/dgnwrite.cpp
// Function: DGNUpdateElemCore
int DGNUpdateElemCore( DGNHandle hDGN, DGNElemCore *psElement, 
                       int nLevel, int nGraphicGroup, int nColor, 
                       int nWeight, int nStyle )

{
    psElement->level = nLevel;
    psElement->graphic_group = nGraphicGroup;
    psElement->color = nColor;
    psElement->weight = nWeight;
    psElement->style = nStyle;

    return DGNUpdateElemCoreExtended( hDGN, psElement );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2c(%rax)
movl 0x10(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x12f50
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdx
addq $0x4, %rdx
callq 0x10fd0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdx
addq $0x10, %rdx
callq 0x10fd0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movzbl 0x5(%rax), %ecx
xorl $0x80, %ecx
movb %cl, 0x5(%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movzbl 0x9(%rax), %ecx
xorl $0x80, %ecx
movb %cl, 0x9(%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movzbl 0xd(%rax), %ecx
xorl $0x80, %ecx
movb %cl, 0xd(%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movzbl 0x11(%rax), %ecx
xorl $0x80, %ecx
movb %cl, 0x11(%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movzbl 0x15(%rax), %ecx
xorl $0x80, %ecx
movb %cl, 0x15(%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movzbl 0x19(%rax), %ecx
xorl $0x80, %ecx
movb %cl, 0x19(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: rurban[P]dgnlib/dgnwrite.cpp
// Function: DGNCreateArcElem2D
DGNElemCore *
DGNCreateArcElem2D( DGNHandle hDGN, int nType, 
                    double dfOriginX, double dfOriginY,
                    double dfPrimaryAxis, double dfSecondaryAxis, 
                    double dfRotation, 
                    double dfStartAngle, double dfSweepAngle )

{
    return DGNCreateArcElem( hDGN, nType, dfOriginX, dfOriginY, 0.0, 
                             dfPrimaryAxis, dfSecondaryAxis, 
                             dfStartAngle, dfSweepAngle, 
                             dfRotation, NULL );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movsd %xmm4, -0x38(%rbp)
movsd %xmm5, -0x40(%rbp)
movsd %xmm6, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movsd -0x28(%rbp), %xmm3
movsd -0x30(%rbp), %xmm4
movsd -0x40(%rbp), %xmm5
movsd -0x48(%rbp), %xmm6
movsd -0x38(%rbp), %xmm7
xorps %xmm2, %xmm2
xorl %eax, %eax
movl %eax, %edx
callq 0x13770
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x1771d
movl $0x1, -0x4(%rbp)
jmp 0x177ac
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x8, %eax
jne 0x17759
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x5, %eax
jne 0x17759
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x17, %eax
jne 0x17759
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x0, %eax
jne 0x17759
movl $0x1, -0x4(%rbp)
jmp 0x177ac
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x8, %eax
je 0x17773
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xc8, %eax
jne 0x1779c
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x9, %eax
jne 0x1779c
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0xfe, %eax
jne 0x1779c
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x2, %eax
je 0x177a5
movl $0x0, -0x4(%rbp)
jmp 0x177ac
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rurban[P]dgnlib/dgnopen.cpp
// Function: DGNSetSpatialFilter
void DGNSetSpatialFilter( DGNHandle hDGN, 
                          double dfXMin, double dfYMin, 
                          double dfXMax, double dfYMax )

{
    DGNInfo     *psDGN = (DGNInfo *) hDGN;

    if( dfXMin == 0.0 && dfXMax == 0.0
        && dfYMin == 0.0 && dfYMax == 0.0 )
    {
        psDGN->has_spatial_filter = FALSE;
        return;
    }

    psDGN->has_spatial_filter = TRUE;
    psDGN->sf_converted_to_uor = FALSE;

    psDGN->sf_min_x_geo = dfXMin;
    psDGN->sf_min_y_geo = dfYMin;
    psDGN->sf_max_x_geo = dfXMax;
    psDGN->sf_max_y_geo = dfYMax;

    DGNSpatialFilterToUOR( psDGN );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x17a78
jp 0x17a78
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x17a78
jp 0x17a78
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x17a78
jp 0x17a78
movsd -0x28(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x17a78
jp 0x17a78
movq -0x30(%rbp), %rax
movl $0x0, 0x20378(%rax)
jmp 0x17ae1
movq -0x30(%rbp), %rax
movl $0x1, 0x20378(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x2037c(%rax)
movsd -0x10(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, 0x20398(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, 0x203a0(%rax)
movsd -0x20(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, 0x203a8(%rax)
movsd -0x28(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, 0x203b0(%rax)
movq -0x30(%rbp), %rdi
callq 0x17af0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x2037c(%rax)
jne 0x17b23
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20378(%rax)
je 0x17b23
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20014(%rax)
jne 0x17b28
jmp 0x17c14
movq -0x8(%rbp), %rax
movsd 0x20398(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd 0x203a0(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd 0x203a8(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movsd 0x203b0(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x10d60
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x10d60
movsd -0x20(%rbp), %xmm0
movsd 0x2795(%rip), %xmm1     # 0x1a338
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20388(%rax)
movsd -0x18(%rbp), %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2038c(%rax)
movsd -0x38(%rbp), %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20390(%rax)
movsd -0x30(%rbp), %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20394(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x2037c(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rurban[P]dgnlib/dgnopen.cpp
// Function: DGNClose
void DGNClose( DGNHandle hDGN )

{
    DGNInfo     *psDGN = (DGNInfo *) hDGN;

    VSIFClose( psDGN->fp );
    CPLFree( psDGN->element_index );
    CPLFree( psDGN );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x9cb0
movq -0x10(%rbp), %rax
movq 0x20050(%rax), %rdi
callq 0xa000
movq -0x10(%rbp), %rdi
callq 0xa000
addq $0x10, %rsp
popq %rbp
retq
nop
// File: rurban[P]dgnlib/dgnstroke.cpp
// Function: ComputePointOnArc2D(double, double, double, double, double*, double*)
static void ComputePointOnArc2D( double dfPrimary, double dfSecondary, 
                                 double dfAxisRotation, double dfAngle,
                                 double *pdfX, double *pdfY )

{
    double      dfRadiusSquared, dfRadius, dfX2, dfY2;
    double      dfCosAngle = cos(dfAngle);
    double      dfSinAngle = sin(dfAngle);
    double      dfPrimarySquared = dfPrimary * dfPrimary;
    double      dfSecondarySquared = dfSecondary * dfSecondary;

    dfRadiusSquared = (dfPrimarySquared * dfSecondarySquared)
        / (dfSecondarySquared * dfCosAngle * dfCosAngle
           + dfPrimarySquared * dfSinAngle * dfSinAngle);

    dfRadius = sqrt(dfRadiusSquared);

    dfX2 = dfRadius * cos(dfAngle);
    dfY2 = dfRadius * sin(dfAngle);

    *pdfX = dfX2 * cos(dfAxisRotation) - dfY2 * sin(dfAxisRotation);
    *pdfY = dfX2 * sin(dfAxisRotation) + dfY2 * cos(dfAxisRotation);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x2540
movsd %xmm0, -0x58(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x20b0
movsd %xmm0, -0x60(%rbp)
movsd -0x8(%rbp), %xmm0
mulsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x10(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movsd -0x68(%rbp), %xmm0
mulsd -0x70(%rbp), %xmm0
movsd -0x70(%rbp), %xmm1
mulsd -0x58(%rbp), %xmm1
movsd -0x58(%rbp), %xmm3
movsd -0x68(%rbp), %xmm2
mulsd -0x60(%rbp), %xmm2
mulsd -0x60(%rbp), %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x2220
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0xb0(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x2540
movaps %xmm0, %xmm1
movsd -0xb0(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0xa8(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x20b0
movaps %xmm0, %xmm1
movsd -0xa8(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x90(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x2540
movsd %xmm0, -0x98(%rbp)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0xa0(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x20b0
movsd -0xa0(%rbp), %xmm1
movsd -0x98(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x90(%rbp), %xmm0
mulsd %xmm3, %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x20b0
movsd %xmm0, -0x80(%rbp)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x88(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x2540
movsd -0x88(%rbp), %xmm1
movsd -0x80(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x78(%rbp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rcx, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
xorl %esi, %esi
movl $0x800, %edx            # imm = 0x800
callq 0x21a0
movq -0x38(%rbp), %rdi
movq 0x6116(%rip), %rax      # 0x9fc0
movq $0x0, (%rax)
movl -0xc(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x2150
movl -0x44(%rbp), %edi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x20c0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x3ede
jmp 0x3f56
cmpl $0x3f, -0x24(%rbp)
jne 0x3eee
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2340
jmp 0x3ef0
movq 0x60c9(%rip), %rax      # 0x9fc0
cmpq $0x0, (%rax)
je 0x3f40
movq 0x60bc(%rip), %rax      # 0x9fc0
movq (%rax), %rdi
callq 0x2170
movq %rax, %rdi
addq $0x1, %rdi
callq 0x2030
movq %rax, %rdx
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x608a(%rip), %rax      # 0x9fc0
movq (%rax), %rsi
callq 0x22a0
jmp 0x3f51
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl $0x1, %edx
movq %rdx, (%rax,%rcx,8)
jmp 0x3e9f
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %r9, -0x40(%rbp)
movb %sil, %al
movq 0x10(%rbp), %rsi
movq %rsi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movsbq -0x9(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x3ff4
movq -0x30(%rbp), %rax
movsbq -0x9(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x23e0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0x3fcc
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x3ff2
movq -0x40(%rbp), %rsi
movq 0x6019(%rip), %rdi      # 0x9ff0
callq 0x2260
movq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x2260
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2340
jmp 0x4022
cmpl $0x0, -0x10(%rbp)
je 0x4020
movq -0x40(%rbp), %rsi
movq 0x5feb(%rip), %rdi      # 0x9ff0
callq 0x2260
movq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x2260
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2340
jmp 0x4022
movl -0x24(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %r8, -0x40(%rbp)
movq %rcx, -0x38(%rbp)
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movsbq -0x9(%rbp), %rcx
movl $0x1, %edx
cmpq %rdx, (%rax,%rcx,8)
jbe 0x4088
movq -0x30(%rbp), %rax
movsbq -0x9(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x40b6
cmpl $0x0, -0x10(%rbp)
je 0x40b4
movq -0x38(%rbp), %rsi
movq 0x5f57(%rip), %rdi      # 0x9ff0
callq 0x2260
movq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x2260
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2340
jmp 0x40b6
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: yahoo[P]UDPing/src/delay.cc
// Function: checkTimer(timespec*)
long checkTimer (struct timespec* timer) {
    struct timespec time2;
    clock_gettime(CLOCK_REALTIME, &time2);
    long elapsed = (1000000000L * (time2.tv_sec - (*timer).tv_sec)) + (time2.tv_nsec - (*timer).tv_nsec);
    return elapsed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorl %edi, %edi
leaq -0x18(%rbp), %rsi
callq 0x2280
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
subq (%rcx), %rax
imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rdx
subq 0x8(%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0x20e0
cvtsi2sd %eax, %xmm0
movsd 0x3440(%rip), %xmm1     # 0x7660
divsd %xmm1, %xmm0
callq 0x2210
imull $0xf4240, -0xc(%rbp), %ecx # imm = 0xF4240
xorl %eax, %eax
subl %ecx, %eax
cvtsi2sd %eax, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x41b0
cvtsi2sd %rax, %xmm1
movsd -0x18(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movslq -0xc(%rbp), %rax
imulq $0xf4240, %rax, %rax    # imm = 0xF4240
imulq $0xa, %rax, %rax
cvtsi2sd %rax, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x4295
movslq -0xc(%rbp), %rax
imulq $0xf4240, %rax, %rax    # imm = 0xF4240
imulq $0xa, %rax, %rax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x18(%rbp), %xmm0
jb 0x42a1
jmp 0x431a
movsd -0x18(%rbp), %xmm0
movsd 0x33ba(%rip), %xmm1     # 0x7668
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
imulq $0x3b9aca00, -0x28(%rbp), %rax # imm = 0x3B9ACA00
cvtsi2sd %rax, %xmm1
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2100
cmpl $0x0, %eax
je 0x431a
callq 0x2040
cmpl $0x4, (%rax)
jne 0x4308
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x4318
leaq 0x3361(%rip), %rdi      # 0x7670
movb $0x0, %al
callq 0x2110
jmp 0x431a
jmp 0x42da
addq $0x40, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movl $0xe, %edi
callq 0x2330
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x21a0
movslq -0x4(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movslq -0x4(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
xorl %edi, %edi
leaq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x23c0
cmpl $0x0, %eax
je 0x4394
movl $0x1, %edi
leaq 0x32f3(%rip), %rsi      # 0x7680
movb $0x0, %al
callq 0x2270
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: yahoo[P]UDPing/src/protocol.cc
// Function: dumpBuffer(char*)
void dumpBuffer (char* buf) {
    if (!getOptions()->getVerbose()) {
        return;
    }
    packet* ph = (packet*) buf;
    printf ("%s:%ld:%d - %ld:%ld\n", ph->guid, ph->clientStartTime, ph->seqNum, ph->sent.tv_sec, ph->sent.tv_nsec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x4180
movq %rax, %rdi
callq 0x4130
cmpl $0x0, %eax
jne 0x43e0
jmp 0x441d
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movq 0x38(%rax), %r9
leaq 0x327b(%rip), %rdi      # 0x7691
movb $0x0, %al
callq 0x2050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yahoo[P]UDPing/src/protocol.cc
// Function: makeSocket(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int makeSocket (string host, int port) {
    int fd;
    socklen_t length;
    struct addrinfo* addrinfo;
    int s;
    if ((fd = socket( PF_INET, SOCK_DGRAM, 0 )) < 0) {
        err(1, "Problem creating socket");
    }
    
    stringstream portString;
    portString << port;
    if (s = getaddrinfo (host.c_str(), portString.str().c_str(), NULL, &addrinfo)) {
        err(1, "getaddrinfo: %s\n", gai_strerror(s));
    }

    if (bind(fd, addrinfo->ai_addr, sizeof(struct sockaddr))<0) {
        err(1, "Problem binding");
    }
    
    return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1e8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x2, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x20d0
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
jge 0x4472
movl $0x1, %edi
leaq 0x323b(%rip), %rsi      # 0x76a6
movb $0x0, %al
callq 0x2270
leaq -0x1b0(%rbp), %rdi
callq 0x21e0
leaq -0x1a0(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2400
jmp 0x448f
movq -0x1e8(%rbp), %rdi
callq 0x2150
movq %rax, -0x1f0(%rbp)
leaq -0x1e0(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x22e0
jmp 0x44b7
leaq -0x1e0(%rbp), %rdi
callq 0x2150
movq -0x1f0(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
leaq -0x20(%rbp), %rcx
callq 0x2360
movl %eax, -0x1f4(%rbp)
jmp 0x44e2
movl -0x1f4(%rbp), %eax
movl %eax, -0x24(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x21c0
movl -0x1f4(%rbp), %eax
cmpl $0x0, %eax
je 0x4556
movl -0x24(%rbp), %edi
callq 0x2390
movq %rax, %rdx
leaq 0x31aa(%rip), %rsi      # 0x76be
xorl %eax, %eax
movl $0x1, %edi
callq 0x2270
jmp 0x4522
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x45a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x21c0
jmp 0x45a9
movl -0x10(%rbp), %edi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
movl $0x10, %edx
callq 0x2090
cmpl $0x0, %eax
jge 0x4585
leaq 0x3158(%rip), %rsi      # 0x76cf
xorl %eax, %eax
movl $0x1, %edi
callq 0x2270
jmp 0x4585
movl -0x10(%rbp), %eax
movl %eax, -0x1f8(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x21f0
movl -0x1f8(%rbp), %eax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
leaq -0x1b0(%rbp), %rdi
callq 0x21f0
movq -0x1b8(%rbp), %rdi
callq 0x2420
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x21a0
movl $0x2, -0x44(%rbp)
movl $0x2, -0x40(%rbp)
movl $0x1, -0x48(%rbp)
leaq -0xc0(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x64, %esi
leaq 0x30b3(%rip), %rdx      # 0x76df
movb $0x0, %al
callq 0x23f0
movq -0xc8(%rbp), %rdi
callq 0x2150
movq %rax, %rdi
leaq -0xc0(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq 0x2360
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
je 0x467c
movl -0x10(%rbp), %edi
callq 0x2390
movq %rax, %rdx
movl $0x1, %edi
leaq 0x3049(%rip), %rsi      # 0x76be
movb $0x0, %al
callq 0x2270
movl $0x10, %edi
callq 0x2300
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x50(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rdi
callq 0x2370
movq -0x18(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
pushq %rbx
subq $0x10098, %rsp          # imm = 0x10098
movl 0x30(%rbp), %eax
movl 0x28(%rbp), %eax
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
leaq -0x3c(%rbp), %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x21a0
movl -0x10(%rbp), %eax
movl %eax, -0x38(%rbp)
movw $0x11, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movl %ecx, -0x30(%rbp)
movw 0x4(%rax), %ax
movw %ax, -0x2c(%rbp)
movb $0x6, -0x31(%rbp)
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl 0x10(%rbp), %r8d
movl -0x20(%rbp), %r9d
movl 0x18(%rbp), %ebx
movq 0x20(%rbp), %r11
movl 0x28(%rbp), %r10d
movl 0x30(%rbp), %eax
leaq -0x10065(%rbp), %rdi
movl %ebx, (%rsp)
movq %r11, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movl %eax, 0x18(%rsp)
callq 0x47d0
movl %eax, -0x1006c(%rbp)
leaq -0x10065(%rbp), %rax
movq %rax, -0x10078(%rbp)
movl -0xc(%rbp), %edi
movq -0x10078(%rbp), %rsi
movslq -0x1006c(%rbp), %rdx
xorl %ecx, %ecx
leaq -0x3c(%rbp), %r8
movl $0x14, %r9d
callq 0x2070
movl %eax, -0x1007c(%rbp)
movl -0x1007c(%rbp), %eax
cmpl -0x1006c(%rbp), %eax
je 0x47b6
leaq 0x2f31(%rip), %rdi      # 0x76e2
callq 0x2240
movl 0x28(%rbp), %eax
addq $0x10098, %rsp          # imm = 0x10098
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movw $0x0, -0x16(%rbp)
cmpl $0x1, -0x10(%rbp)
jle 0x4a07
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x2, %rcx
movq %rcx, -0x8(%rbp)
movzwl (%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x10(%rbp)
jmp 0x49de
cmpl $0x0, -0x10(%rbp)
jle 0x4a1a
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x4a1c
movl -0x14(%rbp), %eax
shrl $0x10, %eax
cmpl $0x0, %eax
je 0x4a3c
movl -0x14(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl -0x14(%rbp), %ecx
shrl $0x10, %ecx
addl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x4a1c
movl -0x14(%rbp), %eax
xorl $-0x1, %eax
movw %ax, -0x16(%rbp)
movw -0x16(%rbp), %ax
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl 0xc(%rax), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
addl -0x18(%rbp), %ecx
movl %ecx, -0x18(%rbp)
movl 0xc(%rax), %ecx
shrl $0x10, %ecx
addl -0x18(%rbp), %ecx
movl %ecx, -0x18(%rbp)
movl 0x10(%rax), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
addl -0x18(%rbp), %ecx
movl %ecx, -0x18(%rbp)
movl 0x10(%rax), %ecx
shrl $0x10, %ecx
addl -0x18(%rbp), %ecx
movl %ecx, -0x18(%rbp)
movzbl 0x9(%rax), %eax
movw %ax, -0x1a(%rbp)
movzwl -0x1a(%rbp), %eax
shll $0x8, %eax
movw %ax, -0x1a(%rbp)
movzwl -0x1a(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movzwl -0x4(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movzwl -0x8(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movzwl -0x6(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movzwl -0x4(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x14(%rbp)
jle 0x4b0e
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x2, %rcx
movq %rcx, -0x10(%rbp)
movzwl (%rax), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x14(%rbp)
jmp 0x4ae5
cmpl $0x1, -0x14(%rbp)
jne 0x4b34
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movw %ax, -0x1c(%rbp)
movzwl -0x1c(%rbp), %eax
shll $0x8, %eax
movw %ax, -0x1c(%rbp)
movzwl -0x1c(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x4b36
movl -0x18(%rbp), %eax
shrl $0x10, %eax
cmpl $0x0, %eax
je 0x4b56
movl -0x18(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl -0x18(%rbp), %ecx
shrl $0x10, %ecx
addl %ecx, %eax
movl %eax, -0x18(%rbp)
jmp 0x4b36
movl -0x18(%rbp), %eax
xorl $-0x1, %eax
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x400, -0x4(%rbp)      # imm = 0x400
jge 0x4bab
movq 0x5475(%rip), %rdi      # 0x9ff0
leaq 0x2b6e(%rip), %rsi      # 0x76f0
callq 0x22f0
movq %rax, %rdi
movl -0x4(%rbp), %esi
callq 0x2400
movq %rax, %rdi
movq 0x541c(%rip), %rsi      # 0x9fb8
callq 0x2310
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2340
cmpl $0xea60, -0x4(%rbp)     # imm = 0xEA60
jle 0x4beb
movq 0x5435(%rip), %rdi      # 0x9ff0
leaq 0x2b3d(%rip), %rsi      # 0x76ff
callq 0x22f0
movq %rax, %rdi
movl -0x4(%rbp), %esi
callq 0x2400
movq %rax, %rdi
movq 0x53dc(%rip), %rsi      # 0x9fb8
callq 0x2310
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2340
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x8, %rdi
callq 0x5b00
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
addq $0x8, %rdi
callq 0x5b80
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x5b50
testb $0x1, %al
jne 0x54ef
jmp 0x5532
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x5bb0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x551b
movq -0x38(%rbp), %rdi
callq 0x57a0
movq -0x38(%rbp), %rdi
callq 0x22b0
jmp 0x551d
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
xorl %esi, %esi
callq 0x5bd0
movq %rax, -0x20(%rbp)
jmp 0x54c0
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x554d
movq -0x40(%rbp), %rdi
callq 0x22b0
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x5568
movq -0x48(%rbp), %rdi
callq 0x22b0
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x5b30
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: yahoo[P]UDPing/src/clientsession.cc
// Function: ClientSessionList::getNextSession()
ClientSession* ClientSessionList::getNextSession () {
    ClientSession* nextSession = *curSession;
    curSession++;
    if (curSession == sessions.end()) {
        curSession = sessions.begin();
    }
    return nextSession;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x20, %rdi
callq 0x5bb0
movq -0x38(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x10(%rbp)
addq $0x20, %rdi
xorl %esi, %esi
callq 0x5bd0
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
addq $0x8, %rdi
callq 0x5b80
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x5c00
testb $0x1, %al
jne 0x55e6
jmp 0x5606
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x5b00
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x70(%rbp)
movl %esi, %eax
movq -0x70(%rbp), %rsi
movq %rdi, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x828, %rax            # imm = 0x828
movq %rax, -0x60(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x2160
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x6370
jmp 0x56c2
leaq -0x40(%rbp), %rdi
callq 0x21c0
movq -0x68(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, 0x818(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x838(%rdi)
movq $0x0, 0x820(%rdi)
xorl %esi, %esi
movl %esi, -0x74(%rbp)
movl $0x818, %edx            # imm = 0x818
callq 0x21a0
movq -0x68(%rbp), %rcx
movl -0x74(%rbp), %eax
movb $0x1, (%rcx)
movl %eax, %edi
callq 0x2290
movq -0x68(%rbp), %rdi
movq %rax, 0x8(%rdi)
movl $0x0, 0x28(%rdi)
callq 0x5770
jmp 0x5724
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x21c0
jmp 0x5759
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x6560
movq -0x48(%rbp), %rdi
callq 0x2420
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x2290
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0x838(%rax), %rdi
callq 0x5c30
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
cqto
idivq %rcx
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rdx, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, 0x820(%rax)
jne 0x5842
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x820(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x820(%rcx), %rax
jne 0x5859
movb $0x0, -0x1(%rbp)
jmp 0x586c
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x820(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: yahoo[P]UDPing/src/clientsession.cc
// Function: ClientSession::sendPacket(int)
int ClientSession::sendPacket (int size) {
    if (size < sizeof(packet)) size = sizeof(packet);
    p.header.size = size;
    int n_sent = sendMessage (
                parent->getSocketFD(),
                parent->getIfIndex(),
                parent->getSrcMac(),
                parent->getSrcAddr()->sin_addr.s_addr,
                port,
                dstMacList.nextMac(),
                parent->getDstAddr()->sin_addr.s_addr,
                parent->getDstPort(),
                (char*)&p,
                size,
                sizeof(packet));

    if (n_sent < 0) {
        warn ("Problem sending data");
        exit (-1);
    }
    if (n_sent != size) {
        warn("Sendto attempted %d, sent %d bytes\n",size, n_sent);
    }
    return n_sent;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x48, %rax
jae 0x5929
movl $0x48, -0x14(%rbp)
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x40(%rax)
movq 0x838(%rax), %rdi
callq 0x5c70
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x40(%rbp)
movq 0x838(%rax), %rdi
callq 0x5c90
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x3c(%rbp)
movq 0x838(%rax), %rdi
callq 0x5cb0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq 0x838(%rax), %rdi
callq 0x5cd0
movq -0x20(%rbp), %rdi
movl 0x4(%rax), %eax
movl %eax, -0x30(%rbp)
movl 0x818(%rdi), %eax
movl %eax, -0x2c(%rbp)
addq $0x828, %rdi            # imm = 0x828
callq 0x6600
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq 0x838(%rax), %rdi
callq 0x5cf0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl 0x4(%rcx), %ebx
movq 0x838(%rax), %rdi
callq 0x5d10
movl -0x40(%rbp), %edi
movl -0x3c(%rbp), %esi
movq -0x38(%rbp), %rdx
movl -0x30(%rbp), %ecx
movl -0x2c(%rbp), %r8d
movq -0x28(%rbp), %r9
movq -0x20(%rbp), %r10
movl %eax, %r11d
movl -0x14(%rbp), %eax
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movl $0x48, 0x20(%rsp)
callq 0x46c0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x5a2a
leaq 0x1d8f(%rip), %rdi      # 0x77a8
movb $0x0, %al
callq 0x2110
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2340
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x5a46
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
leaq 0x1d7e(%rip), %rdi      # 0x77bd
movb $0x0, %al
callq 0x2110
movl -0x18(%rbp), %eax
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x657d
jmp 0x65e2
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %eax
cmpl (%rcx), %eax
jge 0x65c7
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movslq 0x4(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x65b6
movq -0x18(%rbp), %rdi
callq 0x22b0
jmp 0x65b8
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0x6588
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x65e2
movq -0x20(%rbp), %rdi
callq 0x22b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: yahoo[P]UDPing/src/maclist.cc
// Function: MacList::toString(unsigned char*, char*)
int MacList::toString (uint8_t *mac, char* buffer) {
    if (mac == 0) {
        strcpy (buffer, "NULL");
        return -1;
    }
    return sprintf (buffer, "%02x:%02x:%02x:%02x:%02x:%02x", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6694
movq -0x20(%rbp), %rdi
leaq 0x119f(%rip), %rsi      # 0x7825
callq 0x22a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x66e3
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movzbl (%rax), %edx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %ecx
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %r8d
movq -0x18(%rbp), %rax
movzbl 0x3(%rax), %r9d
movq -0x18(%rbp), %rax
movzbl 0x4(%rax), %r10d
movq -0x18(%rbp), %rax
movzbl 0x5(%rax), %eax
leaq 0x1159(%rip), %rsi      # 0x782a
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x20a0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
subq $0xa8, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, %rax
movq 0x20(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq %rax, 0xa0(%rsp)
movq %rdi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x30(%rsp)
callq 0x34a0
movq 0x30(%rsp), %rcx
movl 0x358(%rcx), %ecx
cmpq %rcx, %rax
jne 0x5f8d
jmp 0x5fac
leaq 0xd127(%rip), %rdi      # 0x130bb
leaq 0xd13b(%rip), %rsi      # 0x130d6
movl $0x16, %edx
leaq 0xd13e(%rip), %rcx      # 0x130e5
callq 0x31d0
movq 0x30(%rsp), %rcx
movl 0x358(%rcx), %eax
xorl %edx, %edx
divl 0x35c(%rcx)
movl %eax, 0x94(%rsp)
movl $0x0, 0x90(%rsp)
movl $0x0, 0x8c(%rsp)
movq 0x30(%rsp), %rcx
movl 0x8c(%rsp), %eax
cmpl 0x35c(%rcx), %eax
jae 0x60d9
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rsi
movl 0x8c(%rsp), %ecx
movl 0x94(%rsp), %edx
imull %edx, %ecx
movl %ecx, %edx
movl 0x360(%rax), %eax
movl %eax, %ecx
leaq 0x68(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x32d0
movq 0x30(%rsp), %rax
movq 0x10(%rsp), %rsi
movq %rax, 0x18(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x3140
jmp 0x6043
movq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movl $0x1, %edx
callq 0x7fa0
jmp 0x6059
leaq 0x48(%rsp), %rdi
callq 0x31b0
movq 0x30(%rsp), %rdi
callq 0x8200
movl %eax, 0xc(%rsp)
jmp 0x6073
movl 0xc(%rsp), %eax
addl 0x90(%rsp), %eax
movl %eax, 0x90(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x31b0
movl 0x8c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8c(%rsp)
jmp 0x5fdc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x60cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x31b0
leaq 0x68(%rsp), %rdi
callq 0x31b0
jmp 0x60e8
movl 0x90(%rsp), %eax
addq $0xa8, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x3590
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: CMU-SAFARI[P]optimal-seed-solver/HashTree.cc
// Function: TreeNode::TreeNode()
TreeNode::TreeNode() {
	locNum = 0;
	A = NULL;
	C = NULL;
	G = NULL;
	T = NULL;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
leaq 0x14be7(%rip), %rcx     # 0x1acf8
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
retq