LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rsi, 0x28(%rdi)
andl $0x0, 0x8(%rdi)
movq 0x30(%rdi), %rax
movl 0x4(%rdi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
movl (%rdi), %r8d
testl %r8d, %r8d
cmovlel %edx, %r8d
cmpq %r8, %rdx
je 0x596b
movq %rdx, %r10
shlq $0x4, %r10
leaq (%rax,%r10), %r9
movl %edx, 0x8(%rax,%r10)
movl 0x14(%rdi), %r10d
imull %edx, %r10d
movslq %r10d, %r10
shlq $0x3, %r10
addq 0x20(%rdi), %r10
xorpd %xmm0, %xmm0
xorl %r11d, %r11d
cmpq %r11, %rcx
je 0x5961
movsd (%rsi,%r11,8), %xmm1
subsd (%r10,%r11,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %r11
jmp 0x5943
movsd %xmm0, (%r9)
incq %rdx
jmp 0x5914
movq 0x38(%rdi), %rsi
movq %rax, %rdi
jmp 0x59dd
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl (%rdi), %eax
jge 0x59bc
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rsi
cltq
shlq $0x4, %rax
subq %rax, %rsi
callq 0x59ea
movslq (%rbx), %rax
movslq 0x8(%rbx), %rcx
incq %rcx
movl %ecx, 0x8(%rbx)
subq %rcx, %rax
movq 0x30(%rbx), %rcx
shlq $0x4, %rax
movsd (%rcx,%rax), %xmm0
movl 0x8(%rcx,%rax), %eax
popq %rbx
retq
movq 0x6615(%rip), %rax      # 0xbfd8
movq (%rax), %rcx
leaq 0x2787(%rip), %rdi      # 0x8154
pushq $0x1d
popq %rsi
pushq $0x1
popq %rdx
callq 0x22c0
movl 0x8(%rbx), %eax
jmp 0x5983
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
testl %edi, %edi
cmovlel %eax, %edi
xorpd %xmm0, %xmm0
cmpq %rax, %rdi
je 0x5c3b
movsd (%rsi,%rax,8), %xmm1
subsd (%rdx,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x5c1f
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
testl %edi, %edi
cmovlel %eax, %edi
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
cmpq %rax, %rdi
je 0x5c9d
movsd (%rdx,%rax,8), %xmm3
movsd (%rsi,%rax,8), %xmm2
subsd %xmm2, %xmm3
ucomisd %xmm1, %xmm3
jbe 0x5c6e
mulsd %xmm3, %xmm3
addsd %xmm3, %xmm0
jmp 0x5c98
subsd (%rcx,%rax,8), %xmm2
movapd %xmm2, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm0, %xmm3
xorpd %xmm4, %xmm4
cmpltsd %xmm2, %xmm4
andpd %xmm4, %xmm3
andnpd %xmm0, %xmm4
orpd %xmm3, %xmm4
movapd %xmm4, %xmm0
incq %rax
jmp 0x5c4b
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsi), %r15
movq 0x8(%rsi), %rax
cmpq 0x10(%rsi), %rax
je 0x5d4b
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
movups (%rax), %xmm0
movups %xmm0, (%rbx)
movq %r15, %rdi
callq 0x5dca
movzbl 0xc(%rbx), %eax
cmpl $0x70, %eax
je 0x5d37
cmpl $0x6b, %eax
jne 0x5d3b
leaq 0x8(%rbx), %rsi
leaq 0x28(%r14), %r12
leaq 0x48(%r14), %r13
movq %r15, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0x5de2
movq (%rbx), %rsi
cmpq $0x0, 0x10(%rsi)
je 0x5d1c
addq $0x10, %rsi
movq %r15, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0x5df8
movq (%rbx), %rsi
cmpq $0x0, 0x18(%rsi)
je 0x5d3b
addq $0x18, %rsi
movq %r15, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0x5df8
jmp 0x5d3b
incl 0x4(%r14)
incl (%r14)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x6286(%rip), %rax      # 0xbfd8
movq (%rax), %rcx
leaq 0x2416(%rip), %rdi      # 0x8172
pushq $0x1c
popq %rsi
pushq $0x1
popq %rdx
callq 0x22c0
movq (%r15), %rax
jmp 0x5cbf
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x5dab
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5c9e
cmpb $0x70, 0xc(%rsp)
jne 0x5d87
movl 0x8(%rsp), %eax
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x6226(%rip), %rax      # 0xbfd8
movq (%rax), %rcx
leaq 0x23b6(%rip), %rdi      # 0x8172
pushq $0x1c
popq %rsi
pushq $0x1
popq %rdx
callq 0x22c0
jmp 0x5d84
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movl %edx, %ebp
leaq 0x1eab(%rip), %rsi      # 0x812e
callq 0x2190
movq %rax, %rbx
movq (%r14), %r13
movq 0x8(%r14), %rax
movq %rax, 0x8(%rsp)
cvtsi2sd %ebp, %xmm0
movsd %xmm0, (%rsp)
xorl %r12d, %r12d
leaq 0x1e79(%rip), %r15      # 0x8123
xorl %ebp, %ebp
cmpq 0x8(%rsp), %r13
je 0x6347
movq (%r13), %rax
movq 0x8(%r13), %r14
subq %rax, %r14
je 0x6333
movq %r12, 0x10(%rsp)
shrq $0x2, %r14
movslq (%rax), %rax
addq %rax, %rbp
cvtsi2sd %eax, %xmm0
divsd (%rsp), %xmm0
movq %rbx, %rdi
leaq 0x1e3e(%rip), %rsi      # 0x8124
movb $0x1, %al
callq 0x2200
pushq $0x1
popq %rax
movl %eax, %r12d
movq (%r13), %rax
movq 0x8(%r13), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x632b
movslq (%rax,%r12,4), %rax
addq %rax, %rbp
cvtsi2sd %eax, %xmm0
divsd (%rsp), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x2200
leal 0x1(%r12), %eax
jmp 0x62f0
movq 0x10(%rsp), %r12
addl %r14d, %r12d
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x21d0
addq $0x18, %r13
jmp 0x62ac
movq %rbx, %rdi
callq 0x2160
cvtsi2sd %rbp, %xmm0
cvtsi2sd %r12d, %xmm1
divsd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1338(%rip), %rsi      # 0x812e
callq 0x2190
testq %rax, %rax
je 0x6e24
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x6f8b
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2160
movq 0x51ad(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
leaq 0x12fb(%rip), %rsi      # 0x8130
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2200
leaq 0x12fc(%rip), %rdi      # 0x8142
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x9a0, %rsp            # imm = 0x9A0
cmpl $0x2, %edi
jl 0x16f0
movq 0x8(%rsi), %rdi
callq 0x1140
movl %eax, 0xc(%rsp)
jmp 0x1701
movq 0x38e9(%rip), %rdi      # 0x4fe0
leaq 0xc(%rsp), %rsi
callq 0x1060
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x18a4
leaq 0x54(%rsp), %rdi
callq 0x2158
leaq 0x1902(%rip), %rdi      # 0x3021
leaq 0x1914(%rip), %rsi      # 0x303a
callq 0x1110
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x1922
testq %rbx, %rbx
je 0x17fa
movl 0xc(%rsp), %esi
leaq 0x30(%rsp), %rdi
leaq 0x54(%rsp), %rdx
movq %rbx, %rcx
callq 0x1f20
movq %rax, %r14
testb $0x1, %r14b
je 0x180a
leaq 0x10(%rsp), %r15
leaq 0x54(%rsp), %rsi
movq %r15, %rdi
callq 0x21e4
movq 0x3852(%rip), %rdi      # 0x4fd0
movq %r15, %rsi
callq 0x10c0
shrq $0x20, %r14
leaq 0x10(%rsp), %rdi
callq 0x1050
movq 0x3835(%rip), %r15      # 0x4fd0
leaq 0x189b(%rip), %rsi      # 0x303d
movq %r15, %rdi
callq 0x10d0
incl %r14d
movq %rax, %rdi
movl %r14d, %esi
callq 0x1170
pushq $0x2
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1100
leaq 0x18b3(%rip), %rsi      # 0x307f
movq %r15, %rdi
callq 0x10d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x1030
shrq $0xc, %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x1070
leaq 0x190e(%rip), %rsi      # 0x3103
movq %rax, %rdi
jmp 0x1818
movq 0x37cf(%rip), %rdi      # 0x4fd0
leaq 0x18bb(%rip), %rsi      # 0x30c3
jmp 0x1818
movq 0x37bf(%rip), %rdi      # 0x4fd0
leaq 0x1898(%rip), %rsi      # 0x30b0
callq 0x10d0
xorl %eax, %eax
addq $0x9a0, %rsp            # imm = 0x9A0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x1180
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/madpilot[P]mDNSResolver/test/catch.h
// Function: Catch::getResultCapture()
IResultCapture& getResultCapture() {
        if( IResultCapture* capture = getCurrentContext().getResultCapture() )
            return *capture;
        else
            throw std::logic_error( "No result capture instance" );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
callq 0xc78d
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
testq %rax, %rax
je 0xb08b
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xa1e0
movq %rax, %rbx
leaq 0x3182a(%rip), %rsi     # 0x3c8c7
movq %rax, %rdi
callq 0xa540
movq 0x4ef24(%rip), %rsi     # 0x59fd0
movq 0x4eefd(%rip), %rdx     # 0x59fb0
movq %rbx, %rdi
callq 0xa680
movq %rax, %r14
movq %rbx, %rdi
callq 0xa2f0
movq %r14, %rdi
callq 0xa6c0
// File: /workspace/github_cpp_makefile_star2_O2/madpilot[P]mDNSResolver/test/catch.h
// Function: Catch::enforceNoDuplicateTestCases(std::vector<Catch::TestCase, std::allocator<Catch::TestCase>> const&)
void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions ) {
        std::set<TestCase> seenFunctions;
        for( std::vector<TestCase>::const_iterator it = functions.begin(), itEnd = functions.end();
            it != itEnd;
            ++it ) {
            std::pair<std::set<TestCase>::const_iterator, bool> prev = seenFunctions.insert( *it );
            if( !prev.second ) {
                std::ostringstream ss;

                ss  << Colour( Colour::Red )
                    << "error: TEST_CASE( \"" << it->name << "\" ) already defined.\n"
                    << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << "\n"
                    << "\tRedefined at " << it->getTestCaseInfo().lineInfo << std::endl;

                throw std::runtime_error(ss.str());
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq -0x68(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq (%rdi), %rbx
movq 0x8(%rdi), %r12
leaq -0x70(%rbp), %r15
cmpq %r12, %rbx
je 0xbcbd
movq %r15, %rdi
movq %rbx, %rsi
callq 0x27e62
testb $0x1, %dl
je 0xbcd6
addq $0x118, %rbx            # imm = 0x118
jmp 0xbc9f
leaq -0x70(%rbp), %rdi
callq 0x17d6a
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x1e8(%rbp), %rdi
callq 0xa500
movb $0x0, -0x40(%rbp)
pushq $0x2
popq %rdi
callq 0xc7f0
leaq 0x30c1e(%rip), %rsi     # 0x3c916
leaq -0x1e8(%rbp), %rdi
callq 0xa3c0
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa360
leaq 0x30c14(%rip), %rsi     # 0x3c92a
movq %rax, %rdi
callq 0xa3c0
leaq 0x30c1b(%rip), %rsi     # 0x3c940
movq %rax, %rdi
callq 0xa3c0
movq %rax, %r15
addq $0x100, %r14            # imm = 0x100
movq %rax, %rdi
movq %r14, %rsi
callq 0xbe1e
leaq 0x31d8a(%rip), %rsi     # 0x3dad3
movq %r15, %rdi
callq 0xa3c0
leaq 0x30bf8(%rip), %rsi     # 0x3c950
movq %rax, %rdi
callq 0xa3c0
movq %rax, %r14
addq $0xe0, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xbe1e
movq %r14, %rdi
callq 0xa1d0
leaq -0x40(%rbp), %rdi
callq 0xc91c
pushq $0x10
popq %rdi
callq 0xa1e0
movq %rax, %rbx
leaq -0x1e0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0xa5e0
movb $0x1, %r15b
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0xa630
xorl %r15d, %r15d
movq 0x4e236(%rip), %rsi     # 0x59ff0
movq 0x4e1e7(%rip), %rdx     # 0x59fa8
movq %rbx, %rdi
callq 0xa680
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0xa7d8
testb %r15b, %r15b
jne 0xbddf
jmp 0xbdfa
movq %rax, %r14
movq %rbx, %rdi
callq 0xa2f0
jmp 0xbdfa
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0xc91c
jmp 0xbdfa
movq %rax, %r14
leaq -0x1e8(%rbp), %rdi
callq 0xa0c0
jmp 0xbe0d
jmp 0xbe0a
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x17d6a
movq %r14, %rdi
callq 0xa6c0
// File: /workspace/github_cpp_makefile_star2_O2/madpilot[P]mDNSResolver/test/catch.h
// Function: Catch::toString(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&)
std::string toString( std::wstring const& value ) {

    std::string s;
    s.reserve( value.size() );
    for(size_t i = 0; i < value.size(); ++i )
        s += value[i] <= 0xff ? static_cast<char>( value[i] ) : '?';
    return Catch::toString( s );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rsi, %r14
movq %rdi, %rbx
movb $0x0, (%rax)
movq 0x8(%rsi), %rsi
leaq -0x48(%rbp), %rdi
callq 0xa5c0
xorl %r12d, %r12d
pushq $0x3f
popq %r13
leaq -0x48(%rbp), %r15
cmpq 0x8(%r14), %r12
jae 0xe24b
movq (%r14), %rax
movl (%rax,%r12,4), %eax
cmpl $0x100, %eax            # imm = 0x100
cmovgel %r13d, %eax
movsbl %al, %esi
movq %r15, %rdi
callq 0xa340
incq %r12
jmp 0xe225
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0xdfdb
leaq -0x48(%rbp), %rdi
callq 0xa7d8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe274
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0xa7d8
movq %rbx, %rdi
callq 0xa6c0
// File: /workspace/github_cpp_makefile_star2_O2/madpilot[P]mDNSResolver/test/catch.h
// Function: Catch::CumulativeReporterBase::sectionEnded(Catch::SectionStats const&)
virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE {
            assert( !m_sectionStack.empty() );
            SectionNode& node = *m_sectionStack.back();
            node.stats = sectionStats;
            m_sectionStack.pop_back();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0xb0(%rdi), %rax
cmpq %rax, 0xa8(%rdi)
je 0x12d81
movq %rdi, %rbx
addq $0xa8, %rbx
movq -0x8(%rax), %rdi
addq $0x10, %rdi
callq 0x22f1e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x22f66
leaq 0x2aa07(%rip), %rdi     # 0x3d78f
leaq 0x29c79(%rip), %rsi     # 0x3ca08
leaq 0x2aa64(%rip), %rcx     # 0x3d7fa
movl $0x2239, %edx           # imm = 0x2239
callq 0xa280
// File: /workspace/github_cpp_makefile_star2_O2/madpilot[P]mDNSResolver/test/catch.h
// Function: Catch::ExceptionTranslatorRegistry::tryTranslators[abi:cxx11]() const
std::string tryTranslators() const {
            if( m_translators.empty() )
                throw;
            else
                return m_translators[0]->translate( m_translators.begin()+1, m_translators.end() );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rdx
movq 0x10(%rsi), %rcx
cmpq %rcx, %rdx
je 0x18237
movq %rdi, %rbx
movq (%rdx), %rsi
addq $0x8, %rdx
movq (%rsi), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0xa560
// File: /workspace/github_cpp_makefile_star2_O2/madpilot[P]mDNSResolver/test/catch.h
// Function: Catch::GeneratorsForTest::moveNext()
bool moveNext() {
            std::vector<IGeneratorInfo*>::const_iterator it = m_generatorsInOrder.begin();
            std::vector<IGeneratorInfo*>::const_iterator itEnd = m_generatorsInOrder.end();
            for(; it != itEnd; ++it ) {
                if( (*it)->moveNext() )
                    return true;
            }
            return false;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x38(%rdi), %rcx
movq 0x40(%rdi), %rbx
movq %rcx, %r14
cmpq %rbx, %rcx
je 0x18fea
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x8(%r14), %rcx
testb %al, %al
je 0x18fd1
cmpq %rbx, %r14
setne %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/madpilot[P]mDNSResolver/test/catch.h
// Function: Catch::Clara::Parser::handleOpt(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 handleOpt( std::size_t i, char c, std::string const& arg, std::vector<Token>& tokens ) {
            if( std::string( ":=\0", 3 ).find( c ) == std::string::npos )
                return mode;

            std::string optName = arg.substr( from, i-from );
            if( mode == ShortOpt )
                for( std::size_t j = 0; j < optName.size(); ++j )
                    tokens.push_back( Token( Token::ShortOpt, optName.substr( j, 1 ) ) );
            else if( mode == SlashOpt && optName.size() == 1 )
                tokens.push_back( Token( Token::ShortOpt, optName ) );
            else
                tokens.push_back( Token( Token::LongOpt, optName ) );
            return None;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, %rbx
movq %rcx, -0x30(%rbp)
movq %rsi, %r12
movq %rdi, %r14
leaq -0x68(%rbp), %rax
movq %rax, -0x10(%rax)
movl $0x3d3a, (%rax)         # imm = 0x3D3A
movq $0x3, -0x8(%rax)
leaq -0x78(%rbp), %r13
movq %r13, %rdi
movl %edx, %esi
xorl %edx, %edx
callq 0xa4e0
movq %rax, %r15
movq %r13, %rdi
callq 0xa7d8
cmpq $-0x1, %r15
je 0x1df45
movq 0x8(%r14), %rdx
subq %rdx, %r12
leaq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %r12, %rcx
callq 0xa400
movl (%r14), %eax
cmpl $0x2, %eax
je 0x1df4a
cmpl $0x3, %eax
jne 0x1df77
leaq -0x70(%rbp), %r14
xorl %r15d, %r15d
leaq -0x98(%rbp), %r12
cmpq -0x48(%rbp), %r15
jae 0x1dfa3
movq %r12, %rdi
leaq -0x50(%rbp), %rsi
movq %r15, %rdx
pushq $0x1
popq %rcx
callq 0xa400
movl $0x1, -0x78(%rbp)
movq %r14, %rdi
movq %r12, %rsi
callq 0xa510
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1e17a
movq %r14, %rdi
callq 0xa7d8
movq %r12, %rdi
callq 0xa7d8
incq %r15
jmp 0x1def7
movl (%r14), %eax
jmp 0x1dfae
cmpq $0x1, -0x48(%rbp)
jne 0x1df77
leaq -0x70(%rbp), %r14
movl $0x1, -0x8(%r14)
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0xa510
leaq -0x78(%rbp), %rsi
movq %rbx, %rdi
callq 0x1e17a
jmp 0x1df9b
leaq -0x70(%rbp), %r14
movl $0x2, -0x8(%r14)
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0xa510
leaq -0x78(%rbp), %rsi
movq %rbx, %rdi
callq 0x1e17a
movq %r14, %rdi
callq 0xa7d8
leaq -0x50(%rbp), %rdi
callq 0xa7d8
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1dfc1
jmp 0x1dfcb
movq %rax, %rbx
movq %r14, %rdi
jmp 0x1dfe7
jmp 0x1dfcb
movq %rax, %rbx
jmp 0x1dfec
movq %rax, %rbx
jmp 0x1dfe0
movq %rax, %rbx
movq %r14, %rdi
callq 0xa7d8
leaq -0x98(%rbp), %rdi
callq 0xa7d8
leaq -0x50(%rbp), %rdi
callq 0xa7d8
movq %rbx, %rdi
callq 0xa6c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r12
cmpb $0x0, 0x10(%rdi)
jne 0x1e0a8
movq %rsi, %r15
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andw $0x0, (%rax)
movq $0x1, -0x8(%rax)
movsbl %dl, %esi
movq %r8, %r13
leaq -0x50(%rbp), %rdi
xorl %edx, %edx
movq %rcx, %r14
callq 0xa4e0
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xa7d8
cmpq $-0x1, %rbx
je 0x1e0a8
movq 0x8(%r12), %rdx
subq %rdx, %r15
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0xa400
leaq -0x48(%rbp), %r14
andl $0x0, -0x8(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa510
leaq -0x50(%rbp), %rsi
movq %r13, %rdi
callq 0x1e17a
movq %r14, %rdi
callq 0xa7d8
leaq -0x70(%rbp), %rdi
callq 0xa7d8
xorl %eax, %eax
jmp 0x1e0ac
movl (%r12), %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0xa7d8
jmp 0x1e0cb
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0xa7d8
movq %rbx, %rdi
callq 0xa6c0
// File: /workspace/github_cpp_makefile_star2_O2/madpilot[P]mDNSResolver/test/catch.h
// Function: Catch::Clara::CommandLine<Catch::ConfigData>::validate() const
void validate() const
        {
            if( m_options.empty() && m_positionalArgs.empty() && !m_floatingArg.get() )
                throw std::logic_error( "No options or arguments specified" );

            for( typename std::vector<Arg>::const_iterator  it = m_options.begin(),
                                                            itEnd = m_options.end();
                    it != itEnd; ++it )
                it->validate();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rbx
movq 0x10(%rdi), %r14
cmpq %r14, %rbx
jne 0x1e3e5
cmpq $0x0, 0x48(%rdi)
jne 0x1e3e5
cmpq $0x0, 0x50(%rdi)
jne 0x1e3e5
pushq $0x10
popq %rdi
callq 0xa1e0
movq %rax, %rbx
leaq 0x1f089(%rip), %rsi     # 0x3d441
movq %rax, %rdi
callq 0xa540
movq 0x3bc09(%rip), %rsi     # 0x59fd0
movq 0x3bbe2(%rip), %rdx     # 0x59fb0
movq %rbx, %rdi
callq 0xa680
movq %rbx, %rdi
callq 0x1ea20
addq $0xa8, %rbx
cmpq %r14, %rbx
jne 0x1e3d6
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xa2f0
movq %r14, %rdi
callq 0xa6c0
// File: /workspace/github_cpp_makefile_star2_O2/madpilot[P]mDNSResolver/test/catch.h
// Function: Catch::Config::openStream()
IStream const* openStream() {
            if( m_data.outputFilename.empty() )
                return new CoutStream();
            else if( m_data.outputFilename[0] == '%' ) {
                if( m_data.outputFilename == "%debug" )
                    return new DebugOutStream();
                else
                    throw std::domain_error( "Unrecognised stream: " + m_data.outputFilename );
            }
            else
                return new FileStream( m_data.outputFilename );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpq $0x0, 0x40(%rdi)
je 0x1fdf3
movq %rdi, %r14
addq $0x38, %r14
movq (%r14), %rax
cmpb $0x25, (%rax)
jne 0x1fe0a
leaq 0x1d803(%rip), %rsi     # 0x3d5d3
movq %r14, %rdi
callq 0x117f1
testb %al, %al
je 0x1fe30
movl $0x120, %edi            # imm = 0x120
callq 0xa3e0
movq %rax, %rbx
movq %rax, %rdi
callq 0xc6c2
jmp 0x1fe22
movl $0x118, %edi            # imm = 0x118
callq 0xa3e0
movq %rax, %rbx
movq %rax, %rdi
callq 0xc73a
jmp 0x1fe22
movl $0x208, %edi            # imm = 0x208
callq 0xa3e0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xc596
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xa1e0
movq %rax, %rbx
leaq 0x1d798(%rip), %rsi     # 0x3d5da
leaq -0x38(%rbp), %rdi
movq %r14, %rdx
callq 0x10c67
movb $0x1, %r15b
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0xa490
xorl %r15d, %r15d
movq 0x3a129(%rip), %rsi     # 0x59f90
movq 0x3a132(%rip), %rdx     # 0x59fa0
movq %rbx, %rdi
callq 0xa680
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0xa7d8
testb %r15b, %r15b
jne 0x1fe8c
jmp 0x1fea5
movq %rax, %r14
movq %rbx, %rdi
callq 0xa2f0
jmp 0x1fea5
jmp 0x1fe9a
jmp 0x1fe9a
movq %rax, %r14
movq %rbx, %rdi
callq 0xa380
movq %r14, %rdi
callq 0xa6c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x216fe
movq (%r14), %rax
movq %r14, %rdi
callq *0x70(%rax)
cmpl $0x1, %eax
je 0x216d6
cmpl $0x2, %eax
jne 0x216e2
movq %r14, %rdi
callq 0xdba7
movq %rbx, %rdi
callq 0x2175a
jmp 0x216e2
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x218b8
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x10df6
movq %r14, %rdi
callq 0xa6c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/madpilot[P]mDNSResolver/test/catch.h
// Function: Catch::JunitReporter::writeTestCase(Catch::CumulativeReporterBase::Node<Catch::TestCaseStats, Catch::CumulativeReporterBase::SectionNode> const&)
void writeTestCase( TestCaseNode const& testCaseNode ) {
            TestCaseStats const& stats = testCaseNode.value;

            // All test cases have exactly one section - which represents the
            // test case itself. That section may have 0-n nested sections
            assert( testCaseNode.children.size() == 1 );
            SectionNode const& rootSection = *testCaseNode.children.front();

            std::string className = stats.testInfo.className;

            if( className.empty() ) {
                if( rootSection.childSections.empty() )
                    className = "global";
            }
            writeSection( className, "", rootSection );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x1a0(%rsi), %rax
movq 0x1a8(%rsi), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
jne 0x246c9
movq %rdi, %rbx
movq (%rax), %r14
addq $0x38, %rsi
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0xa510
cmpq $0x0, 0x8(%r15)
jne 0x24685
movq 0xa8(%r14), %rax
cmpq 0xb0(%r14), %rax
jne 0x24685
leaq 0x193d2(%rip), %rsi     # 0x3da4e
leaq -0x40(%rbp), %rdi
callq 0xa760
leaq 0x19448(%rip), %rsi     # 0x3dad4
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0xa180
leaq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x2470c
leaq -0x60(%rbp), %rdi
callq 0xa7d8
leaq -0x40(%rbp), %rdi
callq 0xa7d8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1931d(%rip), %rdi     # 0x3d9ed
leaq 0x18331(%rip), %rsi     # 0x3ca08
leaq 0x19331(%rip), %rcx     # 0x3da0f
movl $0x24da, %edx           # imm = 0x24DA
callq 0xa280
jmp 0x246f8
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xa7d8
jmp 0x246fb
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xa7d8
movq %rbx, %rdi
callq 0xa6c0
// File: /workspace/github_cpp_makefile_star2_O2/madpilot[P]mDNSResolver/test/catch.h
// Function: Catch::CompactReporter::AssertionPrinter::printResultType(Catch::Colour::Code, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
void printResultType( Colour::Code colour, std::string passOrFail ) const {
                if( !passOrFail.empty() ) {
                    {
                        Colour colourGuard( colour );
                        stream << " " << passOrFail;
                    }
                    stream << ":";
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0x8(%rdx)
je 0x27067
movq %rdx, %r14
movq %rdi, %rbx
movb $0x0, -0x11(%rbp)
movl %esi, %edi
callq 0xc7f0
movq (%rbx), %rdi
leaq 0x15966(%rip), %rsi     # 0x3c99d
callq 0xa3c0
movq %rax, %rdi
movq %r14, %rsi
callq 0xa360
leaq -0x11(%rbp), %rdi
callq 0xc91c
movq (%rbx), %rdi
leaq 0x15c36(%rip), %rsi     # 0x3cc90
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xa3c0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x11(%rbp), %rdi
callq 0xc91c
movq %rbx, %rdi
callq 0xa6c0
// File: /workspace/github_cpp_makefile_star2_O2/madpilot[P]mDNSResolver/test/catch.h
// Function: Catch::CompactReporter::AssertionPrinter::printRemainingMessages(Catch::Colour::Code)
void printRemainingMessages( Colour::Code colour = dimColour() ) {
                if ( itMessage == messages.end() )
                    return;

                // using messages.end() directly yields compilation error:
                std::vector<MessageInfo>::const_iterator itEnd = messages.end();
                const std::size_t N = static_cast<std::size_t>( std::distance( itMessage, itEnd ) );

                {
                    Colour colourGuard( colour );
                    stream << " with " << pluralise( N, "message" ) << ":";
                }

                for(; itMessage != itEnd; ) {
                    // If this assertion is a warning ignore any INFO messages
                    if( printInfoMessages || itMessage->type != ResultWas::Info ) {
                        stream << " '" << itMessage->message << "'";
                        if ( ++itMessage != itEnd ) {
                            Colour colourGuard( dimColour() );
                            stream << " and";
                        }
                    }
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq 0x20(%rdi), %r13
movq 0x30(%rdi), %rcx
cmpq %r13, %rcx
je 0x272b9
movq %rdi, %rbx
movq %r13, %rax
subq %rcx, %rax
pushq $0x78
popq %rcx
cqto
idivq %rcx
movq %rax, %r12
movb $0x0, -0x29(%rbp)
movl %esi, %edi
callq 0xc7f0
movq (%rbx), %rdi
leaq 0x16ba4(%rip), %rsi     # 0x3dd75
callq 0xa3c0
movq %rax, %r14
leaq 0x16994(%rip), %rsi     # 0x3db74
leaq -0x50(%rbp), %rdi
leaq -0x2a(%rbp), %rdx
callq 0xa180
leaq -0x70(%rbp), %r15
movq %r12, -0x8(%r15)
leaq -0x50(%rbp), %rsi
movq %r15, %rdi
callq 0xa510
leaq -0x78(%rbp), %rsi
movq %r14, %rdi
callq 0xdab0
leaq 0x15a7c(%rip), %rsi     # 0x3cc90
movq %r14, %rdi
callq 0xa3c0
movq %r15, %rdi
callq 0xa7d8
leaq -0x50(%rbp), %rdi
callq 0xa7d8
leaq -0x29(%rbp), %rdi
callq 0xc91c
leaq 0x1603f(%rip), %r14     # 0x3d27c
leaq 0x16039(%rip), %r15     # 0x3d27d
leaq -0x78(%rbp), %r12
movq 0x30(%rbx), %rax
cmpq %r13, %rax
je 0x272b9
cmpb $0x0, 0x38(%rbx)
jne 0x2725d
cmpl $0x1, 0x48(%rax)
je 0x27248
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xa3c0
movq 0x30(%rbx), %rsi
addq $0x50, %rsi
movq %rax, %rdi
callq 0xa360
movq %rax, %rdi
movq %r15, %rsi
callq 0xa3c0
movq 0x30(%rbx), %rax
addq $0x78, %rax
movq %rax, 0x30(%rbx)
cmpq %r13, %rax
je 0x27248
movb $0x0, -0x78(%rbp)
pushq $0x17
popq %rdi
callq 0xc7f0
movq (%rbx), %rdi
leaq 0x16ad2(%rip), %rsi     # 0x3dd7c
callq 0xa3c0
movq %r12, %rdi
callq 0xc91c
jmp 0x27248
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x272df
jmp 0x272cf
movq %rax, %rbx
jmp 0x272e8
movq %rax, %rbx
movq %r15, %rdi
callq 0xa7d8
leaq -0x50(%rbp), %rdi
callq 0xa7d8
leaq -0x29(%rbp), %rdi
jmp 0x272f5
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0xc91c
movq %rbx, %rdi
callq 0xa6c0
// File: /workspace/github_cpp_makefile_star2_O2/madpilot[P]mDNSResolver/test/catch.h
// Function: Catch::StreamBufImpl<Catch::OutputDebugWriter, 256ul>::sync()
int sync() {
            if( pbase() != pptr() ) {
                m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
                setp( pbase(), epptr() );
            }
            return 0;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x20(%rdi), %rsi
movq 0x28(%rdi), %rdx
cmpq %rdx, %rsi
je 0x28390
movq %rdi, %rbx
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x1e0dc
movq %r14, %rdi
callq 0xdeea
leaq -0x30(%rbp), %rdi
callq 0xa7d8
movq 0x20(%rbx), %rax
movq %rax, 0x28(%rbx)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xa7d8
movq %rbx, %rdi
callq 0xa6c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
andw $0x0, (%rdi)
leaq 0x8(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
andq $0x0, 0x18(%rdi)
leaq 0x30(%rdi), %rax
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x20(%rdi), %r14
movb $0x0, 0x30(%rdi)
movq 0x314bc(%rip), %rax     # 0x59fb8
movq %rax, 0x40(%rdi)
leaq 0x152e0(%rip), %rsi     # 0x3dde7
movq %rax, %rdi
callq 0xa3c0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r14, %rdi
callq 0xa7d8
movq %rbx, %rdi
callq 0x103fc
movq %r15, %rdi
callq 0xa6c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0xa1b0
movq %rax, %r15
addl $0x12, %r15d
movq %rsp, %r12
leaq 0xf(%r15), %rax
andq $-0x10, %rax
subq %rax, %r12
movq %r12, %rsp
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x2945a
movslq %r15d, %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3b528
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
cmpq %rax, %rdx
je 0x29479
movb $0x0, (%rbx,%rax)
incq %rax
jmp 0x2946b
movb $0x1, %r14b
movb %r14b, 0x5(%rbx)
pushq $0xc
popq %rdx
movq %rbx, %rsi
callq 0x2949e
cltq
movl $0x10000, (%rbx,%rax)   # imm = 0x10000
movb %r14b, 0x4(%rbx,%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %edx, %eax
movq (%rdi), %rdx
xorl %r8d, %r8d
xorl %ecx, %ecx
movslq %ecx, %r9
movzbl (%rdx,%r9), %r10d
cmpl $0x2e, %r10d
je 0x294bf
testl %r10d, %r10d
jne 0x294fa
movl %ecx, %edx
subl %r8d, %edx
movl %eax, %r10d
movb %dl, (%rsi,%r10)
movslq %r8d, %r8
incl %eax
movq (%rdi), %rdx
cmpq %r9, %r8
jge 0x294e8
movb (%rdx,%r8), %dl
movl %eax, %r10d
movb %dl, (%rsi,%r10)
incq %r8
jmp 0x294ce
xorl %r8d, %r8d
cmpb $0x2e, (%rdx,%r9)
sete %r8b
addl %r8d, %ecx
movl %ecx, %r8d
incl %ecx
movslq %r8d, %r9
cmpb $0x0, (%rdx,%r9)
jne 0x294ac
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsi, -0x18(%rbp)
testq %rsi, %rsi
je 0x2e843
leaq -0x18(%rbp), %rsi
movq %rbx, %rdi
callq 0x2e860
jmp 0x2e856
leaq 0x104ec(%rip), %rsi     # 0x3ed36
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0xa180
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2ea7a
cmpl $-0x1, %eax
je 0x2e961
cltq
imulq $0x118, %rax, %rax      # imm = 0x118
addq %rax, %rbx
movl $0x118, %edx            # imm = 0x118
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xa330
movl 0x460(%rbx), %eax
cmpl $0x4, %eax
jne 0x2e984
movq %rbx, %rdi
callq 0x2e9b2
movq %rbx, %rdi
movl %eax, %esi
callq 0x2ea02
movl 0x460(%rbx), %eax
cltq
imulq $0x118, %rax, %rdi      # imm = 0x118
addq %rbx, %rdi
movl $0x118, %edx            # imm = 0x118
movq %r14, %rsi
callq 0xa330
incl 0x460(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movslq 0x460(%rdi), %rcx
testq %rcx, %rcx
je 0x2e9fc
pushq %rbp
movq %rsp, %rbp
movq 0x100(%rdi), %rdx
addq $0x218, %rdi            # imm = 0x218
xorl %eax, %eax
movabsq $0x1, %rsi
cmpq %rcx, %rsi
jge 0x2e9fa
movq (%rdi), %r8
cmpq %rdx, %r8
cmovbq %r8, %rdx
cmovbl %esi, %eax
incq %rsi
addq $0x118, %rdi            # imm = 0x118
jmp 0x2e9dc
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movslq 0x460(%rdi), %r13
xorl %r12d, %r12d
pushq $-0x1
popq %rbx
cmpq %r13, %r12
jge 0x2eabe
movq %r15, %rdi
movq %r14, %rsi
callq 0xa520
testl %eax, %eax
je 0x2eabb
incq %r12
addq $0x118, %r15            # imm = 0x118
jmp 0x2ea9b
movl %r12d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
movq %rdi, %r14
movslq 0x460(%rbx), %rax
cmpq %rax, %r15
jge 0x2eb12
movq %r14, %rdi
callq 0x2fe42
movq 0x100(%r14), %rax
movq %rax, -0x40(%rbp,%r15,8)
incq %r15
addq $0x118, %r14            # imm = 0x118
jmp 0x2eae6
xorl %r14d, %r14d
movslq %eax, %rcx
cmpq %rcx, %r14
jge 0x2eb3b
cmpq $0x0, -0x40(%rbp,%r14,8)
jne 0x2eb36
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2ea02
movl 0x460(%rbx), %eax
incq %r14
jmp 0x2eb15
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movslq %esi, %rax
imulq $0x118, %rax, %rax      # imm = 0x118
addq %rdi, %rax
movslq 0x460(%rdi), %rcx
addq $0x110, %rdi            # imm = 0x110
xorl %edx, %edx
cmpq %rcx, %rdx
jge 0x2eb8d
cmpq %rax, (%rdi)
jne 0x2eb81
andq $0x0, (%rdi)
incq %rdx
addq $0x118, %rdi            # imm = 0x118
jmp 0x2eb73
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x10c, %rdi            # imm = 0x10C
callq 0x3b574
xorl %eax, %eax
movb %al, (%rbx)
movb %al, 0x108(%rbx)
andq $0x0, 0x100(%rbx)
andq $0x0, 0x110(%rbx)
movl 0x2a923(%rip), %eax     # 0x5a6a0
movl %eax, 0x10c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10c, %rdi            # imm = 0x10C
callq 0x3b574
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa1f0
andq $0x0, 0x110(%r14)
andq $0x0, 0x100(%r14)
movb $0x0, 0x108(%r14)
movl 0x2a8cf(%rip), %eax     # 0x5a6a0
movl %eax, 0x10c(%r14)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x10c, %rdi            # imm = 0x10C
callq 0x3b574
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
movq %r14, %rsi
callq 0xa1f0
movq %rbx, 0x100(%r15)
movb $0x0, 0x108(%r15)
andq $0x0, 0x110(%r15)
movl 0x2a876(%rip), %eax     # 0x5a6a0
movl %eax, 0x10c(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq