LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sharmaeklavya2[P]ctmeans/src/lib/matrix.cpp
// Function: operator<<(std::ostream&, Matrix const&)
std::ostream& operator<<(std::ostream& os, const Matrix& X) {
    const char indent[] = "\t";
    int m = X.rows(), n = X.cols();
    for(int i=0; i<m; ++i) {
        os << X(i, 0);
        for(int j=1; j<n; ++j) {
            os << indent << X(i, j);
        }
        os << '\n';
    }
    return os;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movw 0x4695(%rip), %ax       # 0x1411a
movw %ax, 0x26(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4cc0
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4cd0
movl %eax, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0xfb4c
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl 0x18(%rsp), %esi
xorl %edx, %edx
callq 0x4310
movq 0x8(%rsp), %rdi
callq 0x22d0
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0xfb2d
movq 0x30(%rsp), %rdi
leaq 0x26(%rsp), %rsi
callq 0x2160
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movl 0x18(%rsp), %esi
movl 0x14(%rsp), %edx
callq 0x4310
movq (%rsp), %rdi
callq 0x22d0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xfae8
movq 0x30(%rsp), %rdi
movl $0xa, %esi
callq 0x21a0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xfaae
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: sharmaeklavya2[P]ctmeans/src/lib/matrix.cpp
// Function: output(_IO_FILE*, Matrix const&)
void output(FILE* fp, const Matrix& X) {
    const char indent[] = "\t";
    int m = X.rows(), n = X.cols();
    for(int i=0; i<m; ++i) {
        std::fprintf(fp, "%lf", X(i, 0));
        for(int j=1; j<n; ++j) {
            std::fprintf(fp, "%s%lf", indent, X(i, j));
        }
        std::fprintf(fp, "\n");
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movw 0x45a5(%rip), %ax       # 0x1411a
movw %ax, 0x36(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4cc0
movl %eax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4cd0
movl %eax, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x30(%rsp), %eax
jge 0xfc59
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl 0x28(%rsp), %esi
xorl %edx, %edx
callq 0x4310
movq 0x18(%rsp), %rdi
leaq 0x4544(%rip), %rsi      # 0x14116
movb $0x1, %al
callq 0x2220
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0xfc36
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x36(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movl 0x28(%rsp), %esi
movl 0x24(%rsp), %edx
callq 0x4310
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x44fa(%rip), %rsi      # 0x1411c
movb $0x1, %al
callq 0x2220
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xfbe1
movq 0x40(%rsp), %rdi
leaq 0x449a(%rip), %rsi      # 0x140dc
movb $0x0, %al
callq 0x2220
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0xfb9e
addq $0x48, %rsp
retq
nop
// File: sharmaeklavya2[P]ctmeans/src/lib/matrix.cpp
// Function: savetxt(char const*, Matrix const&)
void savetxt(const char* fname, const Matrix& X) {
    FILE* fp = fopen(fname, "w");
    if(fp == NULL) {
        fprintf(stderr, "Couldn't open %s\n", fname);
        perror("savetxt");
    }
    else {
        output(fp, X);
        fclose(fp);
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x44a8(%rip), %rsi      # 0x14122
callq 0x21b0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xfcb5
movq 0xc347(%rip), %rax      # 0x1bfd8
movq (%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0x4484(%rip), %rsi      # 0x14124
movb $0x0, %al
callq 0x2220
leaq 0x4488(%rip), %rdi      # 0x14136
callq 0x2110
jmp 0xfccc
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xfb60
movq (%rsp), %rdi
callq 0x2170
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: sharmaeklavya2[P]ctmeans/src/lib/matrix.cpp
// Function: input(_IO_FILE*, Matrix&)
void input(FILE* fp, Matrix& X) {
    MatrixElemType* data = X.data();
    int mn = X.size();
    for(int i=0; i<mn; ++i) {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-result"
        fscanf(fp, "%lf", data+i);
#pragma GCC diagnostic pop
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xfde0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xfdf0
movl %eax, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0xfd4e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rdx
movslq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq 0x43dc(%rip), %rsi      # 0x14116
movb $0x0, %al
callq 0x22c0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xfd13
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: sharmaeklavya2[P]ctmeans/src/lib/matrix.cpp
// Function: loadtxt(char const*, Matrix&)
void loadtxt(const char* fname, Matrix& X) {
    FILE* fp = fopen(fname, "r");
    if(fp == NULL) {
        fprintf(stderr, "Couldn't open %s\n", fname);
        perror("loadtxt");
    }
    else {
        input(fp, X);
        fclose(fp);
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x43c4(%rip), %rsi      # 0x1413e
callq 0x21b0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xfdb5
movq 0xc247(%rip), %rax      # 0x1bfd8
movq (%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0x4384(%rip), %rsi      # 0x14124
movb $0x0, %al
callq 0x2220
leaq 0x4392(%rip), %rdi      # 0x14140
callq 0x2110
jmp 0xfdcc
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xfce0
movq (%rsp), %rdi
callq 0x2170
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: sharmaeklavya2[P]ctmeans/src/lib/nniter.cpp
// Function: NNIterSort::set_point(double const*)
void NNIterSort::set_point(const MatrixElemType* _x_beg) {
    x_beg = _x_beg;
    counter = 0;
    for(int i=0; i<c; ++i) {
        norms[i].second = i;
        double dist = 0;
        for(int j=0; j<d; ++j) {
            dist += (x_beg[j] - C(i, j)) * (x_beg[j] - C(i, j));
        }
        norms[i].first = dist;
    }
    // std::sort(norms.begin(), norms.end());
    std::make_heap(norms.begin(), norms.end(), std::greater<dipair>());
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x68(%rsp), %rcx
movq %rcx, 0x28(%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0x64(%rsp)
movq 0x30(%rsp), %rcx
movl 0x64(%rsp), %eax
cmpl (%rcx), %eax
jge 0xff57
movq 0x30(%rsp), %rdi
movl 0x64(%rsp), %eax
movl %eax, 0x2c(%rsp)
addq $0x30, %rdi
movslq 0x64(%rsp), %rsi
callq 0x10060
movl 0x2c(%rsp), %ecx
movl %ecx, 0x8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x58(%rsp)
movl $0x0, 0x54(%rsp)
movq 0x30(%rsp), %rcx
movl 0x54(%rsp), %eax
cmpl 0x4(%rcx), %eax
jge 0xff1e
movq 0x30(%rsp), %rdi
movq 0x28(%rdi), %rax
movslq 0x54(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x10(%rsp)
addq $0x10, %rdi
movl 0x64(%rsp), %esi
movl 0x54(%rsp), %edx
callq 0x4340
movsd 0x10(%rsp), %xmm0
movq 0x30(%rsp), %rdi
subsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x28(%rdi), %rax
movslq 0x54(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x18(%rsp)
addq $0x10, %rdi
movl 0x64(%rsp), %esi
movl 0x54(%rsp), %edx
callq 0x4340
movsd 0x18(%rsp), %xmm2
movsd 0x20(%rsp), %xmm0
subsd (%rax), %xmm2
movsd 0x58(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x58(%rsp)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0xfe74
movq 0x30(%rsp), %rdi
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
addq $0x30, %rdi
movslq 0x64(%rsp), %rsi
callq 0x10060
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0xfe30
movq 0x30(%rsp), %rdi
addq $0x30, %rdi
callq 0x100d0
movq 0x30(%rsp), %rdi
movq %rax, 0x48(%rsp)
addq $0x30, %rdi
callq 0x10100
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x10080
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: sharmaeklavya2[P]ctmeans/src/lib/nniter.cpp
// Function: NNIterSort::get_neighbor()
typename NNIterSort::dipair NNIterSort::get_neighbor() {
    if(counter >= c) {
        fprintf(stderr, "NNIterSort: counter overflow\n");
    }
    // return norms[counter++];
    std::pop_heap(norms.begin(), norms.end() - counter, std::greater<dipair>());
    return norms[c - (++counter)];
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movl 0x8(%rcx), %eax
cmpl (%rcx), %eax
jl 0xffd2
movq 0xc017(%rip), %rax      # 0x1bfd8
movq (%rax), %rdi
leaq 0x417d(%rip), %rsi      # 0x14148
movb $0x0, %al
callq 0x2220
movq 0x10(%rsp), %rdi
addq $0x30, %rdi
movq %rdi, 0x8(%rsp)
callq 0x100d0
movq 0x8(%rsp), %rdi
movq %rax, 0x30(%rsp)
callq 0x10100
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rsp)
movslq 0x8(%rax), %rsi
leaq 0x20(%rsp), %rdi
callq 0x101b0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x10130
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rdi
movl (%rdx), %eax
movl 0x8(%rdx), %ecx
incl %ecx
movl %ecx, 0x8(%rdx)
subl %ecx, %eax
movslq %eax, %rsi
callq 0x10060
movups (%rax), %xmm0
movaps %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
movl 0x48(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: sharmaeklavya2[P]ctmeans/src/lib/nniter_kd.cpp
// Function: point_point_norm(int, double const*, double const*)
double point_point_norm(int d, const double* p1, const double* p2) {
    double res = 0;
    for(int j=0; j<d; ++j) {
        double p = p1[j] - p2[j];
        res += p*p;
    }
    return res;
}

// Assembly:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
movl -0x24(%rsp), %eax
cmpl -0x4(%rsp), %eax
jge 0x10a4a
movq -0x10(%rsp), %rax
movslq -0x24(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rsp), %rax
movslq -0x24(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rsp)
movsd -0x30(%rsp), %xmm0
movsd -0x30(%rsp), %xmm2
movsd -0x20(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rsp)
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x109ef
movsd -0x20(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
// File: sharmaeklavya2[P]ctmeans/src/lib/nniter_kd.cpp
// Function: point_range_norm(int, double const*, double const*, double const*)
double point_range_norm(int d, const double* p, const double* rmin, const double* rmax) {
    double res = 0;
    for(int j=0; j<d; ++j) {
        double p1 = rmin[j] - p[j];
        if(p1 > 0) {
            res += p1*p1;
        }
        else {
            double p3 = p[j] - rmax[j];
            if(p3 > 0) {
                res += p3*p3;
            }
        }
    }
    return res;
}

// Assembly:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rsp)
movl $0x0, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
cmpl -0x4(%rsp), %eax
jge 0x10b4e
movq -0x18(%rsp), %rax
movslq -0x2c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rsp), %rax
movslq -0x2c(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rsp)
movsd -0x38(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x10ae7
movsd -0x38(%rsp), %xmm0
movsd -0x38(%rsp), %xmm2
movsd -0x28(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rsp)
jmp 0x10b3c
movq -0x10(%rsp), %rax
movslq -0x2c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rsp), %rax
movslq -0x2c(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rsp)
movsd -0x40(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x10b3a
movsd -0x40(%rsp), %xmm0
movsd -0x40(%rsp), %xmm2
movsd -0x28(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rsp)
jmp 0x10b3c
jmp 0x10b3e
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x10a84
movsd -0x28(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
// File: sharmaeklavya2[P]ctmeans/src/lib/nniter_kd.cpp
// Function: NNIterKD::get_neighbor_node()
KDHeapElem NNIterKD::get_neighbor_node() {
    if(pq.empty()) {
        std::fprintf(stderr, "NNIterKD: No neighbors left\n");
    }
    KDHeapElem top(pq.top());
    pq.pop();
    if(top.type == 'k') {
        pq.emplace(top.point, C, x_beg);
        if(top.kdnode->left != nullptr) {
            pq.emplace(top.kdnode->left, C, x_beg);
        }
        if(top.kdnode->right != nullptr) {
            pq.emplace(top.kdnode->right, C, x_beg);
        }
    }
    else if(top.type == 'p') {
        counter++;
    }
    heap_ops++;
    return top;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x8, %rdi
callq 0x10d60
testb $0x1, %al
jne 0x10b8c
jmp 0x10ba4
movq 0xb445(%rip), %rax      # 0x1bfd8
movq (%rax), %rdi
leaq 0x35c9(%rip), %rsi      # 0x14166
movb $0x0, %al
callq 0x2220
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x10d80
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
addq $0x8, %rdi
callq 0x10d90
movq 0x8(%rsp), %rax
movsbl 0xc(%rax), %eax
cmpl $0x6b, %eax
jne 0x10c85
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rcx
movq %rcx, %rdi
addq $0x8, %rdi
addq $0x8, %rsi
movq %rcx, %rdx
addq $0x28, %rdx
addq $0x48, %rcx
callq 0x10de0
movq 0x8(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x10c4c
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, %rdi
addq $0x8, %rdi
movq (%rax), %rsi
addq $0x10, %rsi
movq %rcx, %rdx
addq $0x28, %rdx
addq $0x48, %rcx
callq 0x10e50
movq 0x8(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x10c83
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, %rdi
addq $0x8, %rdi
movq (%rax), %rsi
addq $0x18, %rsi
movq %rcx, %rdx
addq $0x28, %rdx
addq $0x48, %rcx
callq 0x10e50
jmp 0x10ca3
movq 0x8(%rsp), %rax
movsbl 0xc(%rax), %eax
cmpl $0x70, %eax
jne 0x10ca1
movq 0x18(%rsp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0x10ca3
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movl (%rcx), %edx
addl $0x1, %edx
movl %edx, (%rcx)
addq $0x28, %rsp
retq
nopl (%rax)
// File: sharmaeklavya2[P]ctmeans/src/lib/nniter_kd.cpp
// Function: NNIterKD::get_neighbor()
std::pair<double, int> NNIterKD::get_neighbor() {
    if(pq.empty()) {
        std::fprintf(stderr, "NNIterKD: No neighbors left\n");
    }
    KDHeapElem heap_elem;
    do {
        heap_elem = get_neighbor_node();
    } while(heap_elem.type != 'p');
    return std::pair<double, int>(heap_elem.prio, heap_elem.point);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x8, %rdi
callq 0x10d60
testb $0x1, %al
jne 0x10ce2
jmp 0x10cfa
movq 0xb2ef(%rip), %rax      # 0x1bfd8
movq (%rax), %rdi
leaq 0x3473(%rip), %rsi      # 0x14166
movb $0x0, %al
callq 0x2220
leaq 0x28(%rsp), %rdi
callq 0x10ec0
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x10b60
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
movsbl 0x34(%rsp), %eax
cmpl $0x70, %eax
jne 0x10d04
leaq 0x38(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x48(%rsp), %rdi
callq 0x10ed0
movsd 0x48(%rsp), %xmm0
movl 0x50(%rsp), %eax
addq $0x58, %rsp
retq
nop
// File: sharmaeklavya2[P]ctmeans/src/main.cpp
// Function: output_vec_vec_to_file(char const*, char const*, int, int, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&)
double output_vec_vec_to_file(const char* fname, const char* name, int n, int c, const vector<vector<int> >& V) {
    long long sum = 0;
    int count = 0;
    FILE* fp = fopen(fname, "w");
    for(const vector<int>& v: V) {
        if(v.size() > 0) {
            count += v.size();
            sum += v[0];
            fprintf(fp, "%lf", double(v[0])/n);
            for(unsigned i=1; i<v.size(); ++i) {
                sum += v[i];
                fprintf(fp, " %lf", double(v[i])/n);
            }
        }
        fprintf(fp, "\n");
    }
    fclose(fp);
    return double(sum) / count;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movl %ecx, 0x60(%rsp)
movq %r8, 0x58(%rsp)
movq $0x0, 0x50(%rsp)
movl $0x0, 0x4c(%rsp)
movq 0x70(%rsp), %rdi
leaq 0x231a(%rip), %rsi      # 0x14122
callq 0x21b0
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x13080
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x130b0
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x130e0
testb $0x1, %al
jne 0x11e52
jmp 0x11f94
leaq 0x30(%rsp), %rdi
callq 0x13120
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x73c0
cmpq $0x0, %rax
jbe 0x11f72
movq 0x20(%rsp), %rdi
callq 0x73c0
movq %rax, %rcx
movslq 0x4c(%rsp), %rax
addq %rcx, %rax
movl %eax, 0x4c(%rsp)
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x48d0
movslq (%rax), %rax
addq 0x50(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x48d0
movq 0x10(%rsp), %rdi
cvtsi2sdl (%rax), %xmm0
cvtsi2sdl 0x64(%rsp), %xmm1
divsd %xmm1, %xmm0
leaq 0x223b(%rip), %rsi      # 0x14116
movb $0x1, %al
callq 0x2220
movl $0x1, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x73c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x11f70
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x48d0
movslq (%rax), %rax
addq 0x50(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x48d0
movq (%rsp), %rdi
cvtsi2sdl (%rax), %xmm0
cvtsi2sdl 0x64(%rsp), %xmm1
divsd %xmm1, %xmm0
leaq 0x21bc(%rip), %rsi      # 0x14115
movb $0x1, %al
callq 0x2220
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x11eea
jmp 0x11f72
movq 0x40(%rsp), %rdi
leaq 0x215e(%rip), %rsi      # 0x140dc
movb $0x0, %al
callq 0x2220
leaq 0x30(%rsp), %rdi
callq 0x13130
jmp 0x11e3a
movq 0x40(%rsp), %rdi
callq 0x2170
cvtsi2sdq 0x50(%rsp), %xmm0
cvtsi2sdl 0x4c(%rsp), %xmm1
divsd %xmm1, %xmm0
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: sharmaeklavya2[P]ctmeans/src/lib/vecio.h
// Function: void savetxt<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>(char const*, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>)
void savetxt(const char* fname, IterT begin, IterT end) {
    FILE* fp = fopen(fname, "w");
    if(fp == NULL) {
        fprintf(stderr, "Couldn't open %s\n", fname);
        perror("savetxt");
    }
    else {
        output(fp, begin, end);
        fclose(fp);
    }
}

// Assembly:
subq $0x38, %rsp
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
leaq 0xe33(%rip), %rsi       # 0x14122
callq 0x21b0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x1332c
movq 0x8cd0(%rip), %rax      # 0x1bfd8
movq (%rax), %rdi
movq 0x20(%rsp), %rdx
leaq 0xe0d(%rip), %rsi       # 0x14124
movb $0x0, %al
callq 0x2220
leaq 0xe11(%rip), %rdi       # 0x14136
callq 0x2110
jmp 0x1335e
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x138d0
movq 0x18(%rsp), %rdi
callq 0x2170
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: davidgfnet[P]tadns/tadns.cc
// Function: usage(char const*)
static void usage(const char *prog) {
    (void) fprintf(stderr,
        "usage: %s [-q-type] <domain> [<domain>]\n"
        " example: %s -a example.com google.com\n", prog, prog);
    exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x20bfd(%rip), %rax     # 0x27fd0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rcx
leaq 0x12f76(%rip), %rsi     # 0x1a35b
movb $0x0, %al
callq 0x3490
movl $0x1, %edi
callq 0x33f0
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH03_StringsVectorsAndArrays/examples/string_size2.cc
// Function: main
int main() 
{
	string line;

	// read input a line at a time and print lines that are longer than 80 characters
	while (getline(cin, line))
		if (line.size() > 80)
			cout << line << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x10a0
movq 0x2db1(%rip), %rdi      # 0x3fe0
leaq -0x28(%rbp), %rsi
callq 0x1030
movq %rax, -0x40(%rbp)
jmp 0x123e
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x1090
movb %al, -0x41(%rbp)
jmp 0x1256
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x125f
jmp 0x12b4
leaq -0x28(%rbp), %rdi
callq 0x1050
cmpq $0x50, %rax
jbe 0x12af
movq 0x2d5b(%rip), %rdi      # 0x3fd0
leaq -0x28(%rbp), %rsi
callq 0x1070
movq %rax, -0x50(%rbp)
jmp 0x1284
movq -0x50(%rbp), %rdi
movq 0x2d31(%rip), %rsi      # 0x3fc0
callq 0x1080
jmp 0x1296
jmp 0x12af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1040
jmp 0x12cd
jmp 0x1228
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1040
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x10c0
// File: ruankotovich[P]B-Tree/src/seek1.cpp
// Function: main
int main(int argc, char** argv)
{
    int id;
    
    if(argc>1){ id = atoi(argv[1]);}else{std::cin >> id;}
    PrimaryBTree btree;
    
    Article_t a;
    FILE* indexFile = fopen("files/primaryindex.block", "rb");

    btree.readRoot(indexFile);

    if (indexFile != NULL) {
        auto result = btree.getArticle(id, &a, indexFile);

        if (result.first) {
            cout << a.toString();
            cout << "\n\nNumber of block read in PrimaryBTree Index to find the record: " << result.second + 1;
            fseek(indexFile, 0, SEEK_END);
            cout << "\n\nTotal number of blocks in primary index file: " << ((ftell(indexFile) / sizeof(AbstractBlock_t))) << "\n";
        } else {
            cout << "Record not found.\n";
        }
    }
    else {
        cout << "There isn't a primary index file.\n";
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x9e0, %rsp            # imm = 0x9E0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x19a1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1150
movl %eax, -0x14(%rbp)
jmp 0x19b1
movq 0x4638(%rip), %rdi      # 0x5fe0
leaq -0x14(%rbp), %rsi
callq 0x1060
leaq -0x38(%rbp), %rdi
callq 0x1c90
leaq -0x984(%rbp), %rdi
callq 0x3170
leaq 0x2654(%rip), %rdi      # 0x4021
leaq 0x2666(%rip), %rsi      # 0x403a
callq 0x1120
movq %rax, -0x990(%rbp)
movq -0x990(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1d80
cmpq $0x0, -0x990(%rbp)
je 0x1b1f
movl -0x14(%rbp), %esi
movq -0x990(%rbp), %rcx
leaq -0x38(%rbp), %rdi
leaq -0x984(%rbp), %rdx
callq 0x29f0
movq %rax, -0x998(%rbp)
testb $0x1, -0x998(%rbp)
je 0x1b0a
leaq -0x9b8(%rbp), %rdi
movq %rdi, -0x9d0(%rbp)
leaq -0x984(%rbp), %rsi
callq 0x3240
movq -0x9d0(%rbp), %rsi
movq 0x457c(%rip), %rdi      # 0x5fd0
callq 0x10c0
jmp 0x1a5b
leaq -0x9b8(%rbp), %rdi
callq 0x1070
movq 0x4562(%rip), %rdi      # 0x5fd0
leaq 0x25c8(%rip), %rsi      # 0x403d
callq 0x10e0
movq %rax, %rdi
movl -0x994(%rbp), %esi
addl $0x1, %esi
callq 0x1170
movq -0x990(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1110
movq 0x4529(%rip), %rdi      # 0x5fd0
leaq 0x25d1(%rip), %rsi      # 0x407f
callq 0x10e0
movq %rax, -0x9d8(%rbp)
movq -0x990(%rbp), %rdi
callq 0x1030
movq -0x9d8(%rbp), %rdi
movq %rax, %rsi
shrq $0xc, %rsi
callq 0x1050
movq %rax, %rdi
leaq 0x2620(%rip), %rsi      # 0x4103
callq 0x10e0
jmp 0x1b1d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x9c0(%rbp)
movl %eax, -0x9c4(%rbp)
leaq -0x9b8(%rbp), %rdi
callq 0x1070
jmp 0x1b3d
movq 0x44bf(%rip), %rdi      # 0x5fd0
leaq 0x2598(%rip), %rsi      # 0x40b0
callq 0x10e0
jmp 0x1b32
movq 0x44aa(%rip), %rdi      # 0x5fd0
leaq 0x2596(%rip), %rsi      # 0x40c3
callq 0x10e0
xorl %eax, %eax
addq $0x9e0, %rsp            # imm = 0x9E0
popq %rbp
retq
movq -0x9c0(%rbp), %rdi
callq 0x1180
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH01_GettingStarted/examples/for_ex.cc
// Function: main
int main()
{
	int sum = 0;
	for (int i = -100; i <= 100; ++i)
    	sum += i;
	std::cout << sum << std::endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0xffffff9c, -0xc(%rbp) # imm = 0xFFFFFF9C
cmpl $0x64, -0xc(%rbp)
jg 0x11e7
movl -0xc(%rbp), %eax
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x11cd
movl -0x8(%rbp), %esi
movq 0x2de7(%rip), %rdi      # 0x3fd8
callq 0x1060
movq %rax, %rdi
movq 0x2dc8(%rip), %rsi      # 0x3fc8
callq 0x1040
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: madpilot[P]mDNSResolver/test/catch.h
// Function: Catch::Clara::Parser::handlePositional(unsigned long, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<Catch::Clara::Parser::Token, std::allocator<Catch::Clara::Parser::Token>>&)
Mode handlePositional( std::size_t i, char c, std::string const& arg, std::vector<Token>& tokens ) {
            if( inQuotes || std::string( "\0", 1 ).find( c ) == std::string::npos )
                return mode;

            std::string data = arg.substr( from, i-from );
            tokens.push_back( Token( Token::Positional, data ) );
            return None;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movb 0x10(%rax), %cl
movb $0x0, -0x52(%rbp)
movb $0x0, -0x65(%rbp)
movb $0x1, %al
testb $0x1, %cl
movb %al, -0xb1(%rbp)
jne 0x3f1f7
leaq -0x51(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0xc8c0
movq -0xc8(%rbp), %rcx
movb $0x1, -0x52(%rbp)
leaq 0x455af(%rip), %rsi     # 0x84774
leaq -0x50(%rbp), %rdi
movl $0x1, %edx
callq 0xc560
jmp 0x3f1d5
movb $0x1, -0x65(%rbp)
leaq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movsbl -0x19(%rbp), %esi
callq 0xc650
cmpq $-0x1, %rax
sete %al
movb %al, -0xb1(%rbp)
movb -0xb1(%rbp), %al
movb %al, -0xc9(%rbp)
testb $0x1, -0x65(%rbp)
jne 0x3f20b
jmp 0x3f214
leaq -0x50(%rbp), %rdi
callq 0xc9d8
testb $0x1, -0x52(%rbp)
jne 0x3f21c
jmp 0x3f225
leaq -0x51(%rbp), %rdi
callq 0xc530
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0x3f231
jmp 0x3f264
movq -0xc0(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x3f319
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
testb $0x1, -0x52(%rbp)
jne 0x3f256
jmp 0x3f25f
leaq -0x51(%rbp), %rdi
callq 0xc530
jmp 0x3f325
movq -0xc0(%rbp), %rax
movq -0x28(%rbp), %rsi
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rcx
subq %rdx, %rcx
leaq -0x88(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0xc500
movq -0xe0(%rbp), %rdx
movq -0x30(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0xb0(%rbp), %rdi
xorl %esi, %esi
callq 0x3f360
jmp 0x3f2af
movq -0xd8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x3f330
jmp 0x3f2c4
leaq -0xb0(%rbp), %rdi
callq 0x3d230
movl $0x0, -0x4(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xc9d8
jmp 0x3f319
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x3f30b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x3d230
leaq -0x88(%rbp), %rdi
callq 0xc9d8
jmp 0x3f325
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xc8b0
nop
// File: madpilot[P]mDNSResolver/test/catch.h
// Function: Catch::sortTests(Catch::IConfig const&, std::vector<Catch::TestCase, std::allocator<Catch::TestCase>> const&)
inline std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {

        std::vector<TestCase> sorted = unsortedTestCases;

        switch( config.runOrder() ) {
            case RunTests::InLexicographicalOrder:
                std::sort( sorted.begin(), sorted.end() );
                break;
            case RunTests::InRandomOrder:
                {
                    seedRng( config );
                    RandomNumberGenerator::shuffle( sorted );
                }
                break;
            case RunTests::InDeclarationOrder:
                // already in declaration order
                break;
        }
        return sorted;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rsi
callq 0x48ae0
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq 0x70(%rax), %rax
callq *%rax
movl %eax, -0x44(%rbp)
jmp 0x489be
movl -0x44(%rbp), %eax
testl %eax, %eax
je 0x48a35
jmp 0x489c7
movl -0x44(%rbp), %eax
subl $0x1, %eax
je 0x489f2
jmp 0x489d1
movl -0x44(%rbp), %eax
subl $0x2, %eax
je 0x48a1d
jmp 0x48a37
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x188c0
jmp 0x48a54
movq -0x58(%rbp), %rdi
callq 0x45b00
movq -0x58(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x45b70
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x48bd0
jmp 0x48a1b
jmp 0x48a37
movq -0x10(%rbp), %rdi
callq 0x12200
jmp 0x48a28
movq -0x58(%rbp), %rdi
callq 0x48c10
jmp 0x48a33
jmp 0x48a37
jmp 0x48a37
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x48a4a
movq -0x58(%rbp), %rdi
callq 0x188c0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xc8b0
nopl (%rax)
// File: madpilot[P]mDNSResolver/test/catch.h
// Function: Catch::XmlWriter::XmlWriter()
XmlWriter()
        :   m_tagIsOpen( false ),
            m_needsNewline( false ),
            m_os( &Catch::cout() )
        {
            // We encode control characters, which requires
            // XML 1.1
            // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
            *m_os << "<?xml version=\"1.1\" encoding=\"UTF-8\"?>\n";
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movb $0x0, (%rdi)
movb $0x0, 0x1(%rdi)
addq $0x8, %rdi
movq %rdi, -0x30(%rbp)
callq 0x3b790
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x28(%rbp)
callq 0xc6c0
callq 0xfe40
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x40(%rax)
movq 0x40(%rax), %rdi
leaq 0x28bfa(%rip), %rsi     # 0x85e1e
callq 0xc4b0
jmp 0x5d22b
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xc9d8
movq -0x30(%rbp), %rdi
callq 0x17180
movq -0x10(%rbp), %rdi
callq 0xc8b0
nopl (%rax,%rax)
// File: madpilot[P]mDNSResolver/src/Query.cpp
// Function: mDNSResolver::Query::sendPacket(WiFiUDP&)
void Query::sendPacket(WiFiUDP& socket) {
    int bufferLength = strlen(this->name) + 18;
    unsigned char buffer[bufferLength];
    assemblePacket(buffer, bufferLength);
    socket.write(buffer, bufferLength);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq (%rax), %rdi
callq 0xc220
movq -0x38(%rbp), %rdi
addl $0x12, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rsi
subq %rcx, %rsi
movq %rsi, -0x30(%rbp)
movq %rsi, %rsp
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %edx
callq 0x5ec40
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rdx
callq 0x82f70
movq -0x20(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: madpilot[P]mDNSResolver/src/Query.cpp
// Function: mDNSResolver::Query::assemblePacket(unsigned char*, int)
void Query::assemblePacket(unsigned char *buffer, int bufferLength) {
    for(int i = 0; i < bufferLength; i++) {
      buffer[i] = 0;
    }

    buffer[5] = 0x01;

    int bufferIndex = 12;
    bufferIndex = buildDNSName(buffer, bufferIndex);

    int qtype = 0x01;
    int qclass = 0x01;

    buffer[bufferIndex++] = '\0';
    buffer[bufferIndex++] = (qtype & 0xFF00) >> 8;
    buffer[bufferIndex++] = qtype & 0xFF;
    buffer[bufferIndex++] = (qclass & 0xFF00) >> 8;
    buffer[bufferIndex++] = qclass & 0xFF;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5ec81
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5ec62
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movb $0x1, 0x5(%rax)
movl $0xc, -0x1c(%rbp)
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x5ed50
movl %eax, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl -0x20(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x20(%rbp), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: madpilot[P]mDNSResolver/src/Query.cpp
// Function: mDNSResolver::Query::buildDNSName(unsigned char*, unsigned int)
int Query::buildDNSName(unsigned char *buffer, unsigned int bufferIndex) {
    int wordstart = 0, wordend = 0;

    do {
      if(this->name[wordend] == '.' || this->name[wordend] == '\0') {
        const int wordlen = wordend - wordstart;
        buffer[bufferIndex++] = (unsigned char)wordlen;

        for(int i = wordstart; i < wordend; i++) {
          buffer[bufferIndex++] = this->name[i];
        }

        if(this->name[wordend] == '.') {
          wordend++;
        }
        wordstart = wordend;
      }

      wordend++;
    } while(this->name[wordstart] != '\0');

    return bufferIndex;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
je 0x5eda1
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x5ee21
movl -0x1c(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x5edfe
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5edc9
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x5ee1b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x5ed75
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: madpilot[P]mDNSResolver/test/catch.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Catch::StringMaker<mDNSResolver::Response*>::convert<mDNSResolver::Response>(mDNSResolver::Response*)
static std::string convert( U* p ) {
        if( !p )
            return "NULL";
        else
            return Detail::rawMemoryToString( p );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x69357
leaq -0x11(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xc8c0
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x1da38(%rip), %rsi     # 0x86d66
callq 0xc6b0
jmp 0x69335
leaq -0x11(%rbp), %rdi
callq 0xc530
jmp 0x69364
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0xc530
jmp 0x6936e
movq -0x38(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x69380
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xc8b0
nopw (%rax,%rax)
// File: madpilot[P]mDNSResolver/src/Cache.cpp
// Function: mDNSResolver::Cache::insert(mDNSResolver::Response)
void Cache::insert(Response response) {
    int existing = search(response);
    if(existing != -1) {
      this->list[existing] = response;
      return;
    }

    if(this->size == MDNS_RESOLVER_MAX_CACHE) {
      int i = oldest();
      remove(i);
    }

    this->list[this->size] = response;
    this->size += 1;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x69580
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x6951c
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
imulq $0x118, %rax, %rax      # imm = 0x118
addq %rax, %rdi
movl $0x118, %edx            # imm = 0x118
callq 0xc410
jmp 0x69577
movq -0x20(%rbp), %rax
cmpl $0x4, 0x460(%rax)
jne 0x69541
movq -0x20(%rbp), %rdi
callq 0x695b0
movq -0x20(%rbp), %rdi
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
callq 0x69660
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movslq 0x460(%rdi), %rax
imulq $0x118, %rax, %rax      # imm = 0x118
addq %rax, %rdi
movl $0x118, %edx            # imm = 0x118
callq 0xc410
movq -0x20(%rbp), %rax
movl 0x460(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x460(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: madpilot[P]mDNSResolver/src/Cache.cpp
// Function: mDNSResolver::Cache::oldest()
int Cache::oldest() {
    if(this->size == 0) {
      return -1;
    }

    unsigned long oldestTTL = this->list[0].ttl;
    unsigned int oldestIndex = 0;

    for(int i = 1; i < this->size; i++) {
      if(this->list[i].ttl < oldestTTL) {
        oldestTTL = this->list[i].ttl;
        oldestIndex = i;
      }
    }

    return oldestIndex;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, 0x460(%rax)
jne 0x695d5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x69656
movq -0x28(%rbp), %rax
movq 0x100(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x460(%rcx), %eax
jge 0x69650
movq -0x28(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x118, %rcx, %rcx      # imm = 0x118
addq %rcx, %rax
movq 0x100(%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0x69643
movq -0x28(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x118, %rcx, %rcx      # imm = 0x118
addq %rcx, %rax
movq 0x100(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x69645
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x695f2
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: madpilot[P]mDNSResolver/src/Cache.cpp
// Function: mDNSResolver::Cache::search(char const*)
int Cache::search(const char* name) {
    for(int i = 0; i < this->size; i++) {
      if(strcmp(this->list[i].name, name) == 0) {
        return i;
      }
    }
    return -1;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x460(%rcx), %eax
jge 0x69773
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x118, %rax, %rax      # imm = 0x118
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0xc6d0
cmpl $0x0, %eax
jne 0x69766
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6977a
jmp 0x69768
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6972f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: madpilot[P]mDNSResolver/src/Cache.cpp
// Function: mDNSResolver::Cache::expire()
void Cache::expire() {
    unsigned long ttls[MDNS_RESOLVER_MAX_CACHE];

    for(int i = 0; i < this->size; i++) {
      this->list[i].decrementTTL();
      ttls[i] = this->list[i].ttl;
    }

    for(int i = 0; i < this->size; i++) {
      if(ttls[i] == 0) {
        remove(i);
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x40(%rbp), %rcx
movl -0x34(%rbp), %eax
cmpl 0x460(%rcx), %eax
jge 0x697fe
movq -0x40(%rbp), %rdi
movslq -0x34(%rbp), %rax
imulq $0x118, %rax, %rax      # imm = 0x118
addq %rax, %rdi
callq 0x6be00
movq -0x40(%rbp), %rax
movslq -0x34(%rbp), %rcx
imulq $0x118, %rcx, %rcx      # imm = 0x118
addq %rcx, %rax
movq 0x100(%rax), %rcx
movslq -0x34(%rbp), %rax
movq %rcx, -0x30(%rbp,%rax,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x697ab
movl $0x0, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movl -0x38(%rbp), %eax
cmpl 0x460(%rcx), %eax
jge 0x69839
movslq -0x38(%rbp), %rax
cmpq $0x0, -0x30(%rbp,%rax,8)
jne 0x6982c
movq -0x40(%rbp), %rdi
movl -0x38(%rbp), %esi
callq 0x69660
jmp 0x6982e
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x69805
addq $0x40, %rsp
popq %rbp
retq
nop
// File: madpilot[P]mDNSResolver/src/Cache.cpp
// Function: mDNSResolver::Cache::removeCname(int)
void Cache::removeCname(int index) {
    Response *response = &this->list[index];

    for(int i = 0; i < length(); i++) {
      if(this->list[i].cname == response) {
        this->list[i].cname = NULL;
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movslq -0xc(%rbp), %rcx
imulq $0x118, %rcx, %rcx      # imm = 0x118
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0x69840
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x698f1
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x118, %rcx, %rcx      # imm = 0x118
addq %rcx, %rax
movq 0x110(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x698e4
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x118, %rcx, %rcx      # imm = 0x118
addq %rcx, %rax
movq $0x0, 0x110(%rax)
jmp 0x698e6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x69890
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: madpilot[P]mDNSResolver/src/Response.cpp
// Function: mDNSResolver::Response::Response()
Response::Response() {
    this->name[0] = '\0';
    this->resolved = false;
    this->ttl = 0;
    this->cname = NULL;
    this->ipAddress = INADDR_NONE;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x10c, %rdi            # imm = 0x10C
callq 0x82ff0
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movb $0x0, 0x108(%rax)
movq $0x0, 0x100(%rax)
movq $0x0, 0x110(%rax)
movl 0x4cab6(%rip), %ecx     # 0xb87a0
movl %ecx, 0x10c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: madpilot[P]mDNSResolver/src/Response.cpp
// Function: mDNSResolver::Response::Response(char const*)
Response::Response(const char* name) {
    strncpy(this->name, name, MDNS_MAX_NAME_LEN + 1);
    this->name[MDNS_MAX_NAME_LEN + 1] = '\0';
    this->ttl = 0;
    this->resolved = false;
    this->cname = NULL;
    this->ipAddress = INADDR_NONE;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x10c, %rdi            # imm = 0x10C
callq 0x82ff0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0xc280
movq -0x18(%rbp), %rax
movb $0x0, 0x100(%rax)
movq $0x0, 0x100(%rax)
movb $0x0, 0x108(%rax)
movq $0x0, 0x110(%rax)
movl 0x4ca3c(%rip), %ecx     # 0xb87a0
movl %ecx, 0x10c(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: madpilot[P]mDNSResolver/src/Response.cpp
// Function: mDNSResolver::Response::Response(char const*, unsigned long)
Response::Response(const char* name, unsigned long ttl) {
    strncpy(this->name, name, MDNS_MAX_NAME_LEN + 1);
    this->name[MDNS_MAX_NAME_LEN + 1] = '\0';
    this->ttl = ttl;
    this->resolved = false;
    this->cname = NULL;
    this->ipAddress = INADDR_NONE;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x10c, %rdi            # imm = 0x10C
callq 0x82ff0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0xc280
movq -0x20(%rbp), %rax
movb $0x0, 0x100(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x100(%rax)
movb $0x0, 0x108(%rax)
movq $0x0, 0x110(%rax)
movl 0x4c9c8(%rip), %ecx     # 0xb87a0
movl %ecx, 0x10c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: madpilot[P]mDNSResolver/src/Answer.cpp
// Function: mDNSResolver::Answer::process(unsigned char*, unsigned int, mDNSResolver::Cache&)
MDNS_RESULT Answer::process(unsigned char* buffer, unsigned int len, Cache& cache) {
    if((buffer[2] & 0b10000000) != 0b10000000) {
      // Not an answer packet
      return E_MDNS_OK;
    }

    if(buffer[2] & 0b00000010) {
      // Truncated - we don't know what to do with these
      return E_MDNS_TRUNCATED;
    }

    if (buffer[3] & 0b00001111) {
      return E_MDNS_PACKET_ERROR;
    }

    unsigned int answerCount = (buffer[6] << 8) + buffer[7];
    if(answerCount == 0) {
      return E_MDNS_OK;
    }

    unsigned int offset = 0;

    MDNS_RESULT questionResult = skipQuestions(buffer, len, &offset);
    if(questionResult != E_MDNS_OK) {
      return questionResult;
    }

    MDNS_RESULT answerResult;
    for(int i = 0; i < answerCount; i++) {
      answerResult = resolve(buffer, len, &offset, cache);
      if(answerResult != E_MDNS_OK) {
        return answerResult;
      }
    }

    resolveCnames(cache);

    return answerResult;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
andl $0x80, %eax
cmpl $0x80, %eax
je 0x7eeb3
movl $0x20, -0x4(%rbp)
jmp 0x7ef8a
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x7eecf
movl $0x25, -0x4(%rbp)
jmp 0x7ef8a
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x7eeeb
movl $0x23, -0x4(%rbp)
jmp 0x7ef8a
movq -0x10(%rbp), %rax
movzbl 0x6(%rax), %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movzbl 0x7(%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x7ef12
movl $0x20, -0x4(%rbp)
jmp 0x7ef8a
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x28(%rbp), %rdx
callq 0x7efa0
movl %eax, -0x2c(%rbp)
cmpl $0x20, -0x2c(%rbp)
je 0x7ef3a
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7ef8a
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x7ef7b
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %rdx
callq 0x7f0b0
movl %eax, -0x30(%rbp)
cmpl $0x20, -0x30(%rbp)
je 0x7ef6e
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7ef8a
jmp 0x7ef70
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x7ef41
movq -0x20(%rbp), %rdi
callq 0x7f540
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)