LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/yiboyang[P]VirtualMemory/BackingStore.cpp
// Function: BackingStore::write(int, int)
void BackingStore::write(int pnum, int fnum) {
	assert(!store.eof());

	// seek to the page at pnum
	if (store.seekg(pnum * FRAME_SIZE, ios::beg))
		store.write((char *)Memory[fnum], FRAME_SIZE);
	else
		throw runtime_error("Seek error");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rdi,%rax)
jne 0x39ad
movl %edx, %r14d
movq %rdi, %rbx
shll $0x8, %esi
movslq %esi, %rsi
xorl %edx, %edx
callq 0x22b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x39cc
movslq %r14d, %rsi
shlq $0x8, %rsi
addq 0x45f8(%rip), %rsi      # 0x7f90
addq $0x10, %rbx
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x22a0
leaq 0x16cc(%rip), %rdi      # 0x5080
leaq 0x16d2(%rip), %rsi      # 0x508d
leaq 0x1704(%rip), %rcx      # 0x50c6
movl $0x1a, %edx
callq 0x2180
movl $0x10, %edi
callq 0x2120
movq %rax, %rbx
leaq 0x16db(%rip), %rsi      # 0x50bb
movq %rax, %rdi
callq 0x20f0
movq 0x4601(%rip), %rsi      # 0x7ff0
movq 0x45ba(%rip), %rdx      # 0x7fb0
movq %rbx, %rdi
callq 0x2360
movq %rax, %r14
movq %rbx, %rdi
callq 0x21c0
movq %r14, %rdi
callq 0x2380
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/ALSchwalm[P]cppEvolve/examples/primes.cpp
// Function: treeFitness(evolve::tree::Tree<int> const*)
double treeFitness(const tree::Tree<int>* tree)
{
    double total = 0;
    std::vector<int> used;
    for(nodes::x=0; nodes::x < static_cast<int>(primes.size()); ++nodes::x) {
        auto val = tree->eval();
        if (std::find(primes.begin(), primes.end(), val) != primes.end() &&
            std::find(used.begin(), used.end(), val) == used.end()) {

            used.push_back(val);
            total += 1;
        }
    }
    return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
leaq -0x50(%rbp), %r14
movapd %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movl $0x0, 0x9cba(%rip)      # 0xc144
xorpd %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
leaq 0x4be6(%rip), %r15      # 0x7080
leaq 0x4c07(%rip), %r12      # 0x70a8
leaq -0x2c(%rbp), %r13
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, -0x2c(%rbp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x3ab9
cmpq %r12, %rax
je 0x250f
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %r13, %rdx
callq 0x3b68
movq -0x48(%rbp), %rsi
cmpq %rsi, %rax
jne 0x250f
cmpq -0x40(%rbp), %rax
je 0x24f2
movl -0x2c(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x24fd
movq %r14, %rdi
movq %r13, %rdx
callq 0x3c16
movsd -0x38(%rbp), %xmm0
addsd 0x4afe(%rip), %xmm0     # 0x7008
movsd %xmm0, -0x38(%rbp)
movl 0x9c2f(%rip), %eax      # 0xc144
leal 0x1(%rax), %ecx
movl %ecx, 0x9c26(%rip)      # 0xc144
cmpl $0x9, %eax
jl 0x24a5
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x2531
callq 0x2140
movsd -0x38(%rbp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2547
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x2558
callq 0x2140
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/ALSchwalm[P]cppEvolve/include/cppEvolve/Genome/Tree/Tree.hpp
// Function: void evolve::tree::TreeFactory<int>::addNode<int, int>(int (*)(int, int), std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void addNode(Rtype (*f)(T...), const std::string& name) {
        static_assert(sizeof...(T) > 0,
                      "Node function with 0 arguments should be terminator");
        const auto val = currentID;

        // explicitly capture to avoid bug in gcc
        std::function<BaseNode<Rtype>*()> func = [f, name, val]() {
            return new Node<std::function<Rtype(T...)>>(f, name, val);
        };
        nodes[currentID++] = func;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movl 0x4(%rdi), %r15d
leaq -0x60(%rbp), %rdi
movq %rsi, -0x8(%rdi)
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x3e88
movl %r15d, 0x10(%r14)
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3d4e
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x2a78
callq 0x2140
leaq 0x8(%rbx), %rdi
movl 0x4(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rbx)
leaq -0x68(%rbp), %rsi
movl %eax, (%rsi)
callq 0x3dac
leaq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x3e14
movq -0x28(%rbp), %rax
testq %rax, %rax
je 0x2ab3
leaq -0x38(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2af5
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x2aed
callq 0x2140
jmp 0x2aed
movq %rax, %rbx
movq -0x28(%rbp), %rax
testq %rax, %rax
je 0x2aed
leaq -0x38(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x21f0
movq %rax, %rdi
callq 0x35bd
nop
// File: /workspace/github_cpp_makefile_star2_O3/ALSchwalm[P]cppEvolve/include/cppEvolve/Genome/Tree/Tree.hpp
// Function: evolve::tree::TreeFactory<int>::addTerminator(int (*)(), std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void addTerminator(Rtype (*f)(), const std::string& name) {
        const auto val = currentID;
        std::function<BaseNode<Rtype>*()> func = [f, name, val]() {
            return new Terminator<std::function<Rtype()>>(f, name, val);
        };
        terminators[currentID++] = func;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movl 0x4(%rdi), %r15d
leaq -0x60(%rbp), %rdi
movq %rsi, -0x8(%rdi)
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x3e88
movl %r15d, 0x10(%r14)
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x4f4a
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x2c28
callq 0x2140
leaq 0x38(%rbx), %rdi
movl 0x4(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rbx)
leaq -0x68(%rbp), %rsi
movl %eax, (%rsi)
callq 0x3dac
leaq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x3e14
movq -0x28(%rbp), %rax
testq %rax, %rax
je 0x2c63
leaq -0x38(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2ca5
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x2c9d
callq 0x2140
jmp 0x2c9d
movq %rax, %rbx
movq -0x28(%rbp), %rax
testq %rax, %rax
je 0x2c9d
leaq -0x38(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x21f0
movq %rax, %rdi
callq 0x35bd
// File: /workspace/github_cpp_makefile_star2_O3/ALSchwalm[P]cppEvolve/include/cppEvolve/Genome/Tree/Crossover.hpp
// Function: evolve::tree::Tree<int>* evolve::tree::crossover::singlePoint<int>(evolve::tree::Tree<int> const*, evolve::tree::Tree<int> const*)
Tree<T>* singlePoint(const Tree<T>* left, const Tree<T>* right) {
    auto tree = left->clone(); // Copy left

    auto treeDepth = right->getDepth();
    auto depth = utils::random_uint(treeDepth);

    auto sourceNode = right->root; // Crossover from the right to the left
    BaseNode<T>* prevSourceNode = nullptr;

    for (unsigned int i = 0; i < depth; ++i) {
        if (sourceNode->getChildren().empty()) {
            sourceNode = prevSourceNode; // Do not copy terminators
            break;
        }
        prevSourceNode = sourceNode;
        sourceNode = sourceNode->getChildren()[utils::random_uint(
            sourceNode->getChildren().size())];
    }

    auto currentNode = tree->root;
    BaseNode<T>* prevNode = nullptr;

    for (unsigned int i = 0; i < depth; ++i) {
        prevNode = currentNode;
        auto nextNodeLocation =
            utils::random_uint(currentNode->getChildren().size());
        currentNode = currentNode->getChildren()[nextNodeLocation];

        if (sourceNode->getDepth() == currentNode->getDepth()) {
            auto& children = prevNode->getChildren();
            delete currentNode;
            children[nextNodeLocation] = sourceNode->clone();
            break;
        } else if (currentNode->getChildren().empty()) {
            break; // This point should never be reached
        }
    }

    return tree;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
callq 0x5458
movq %rax, -0x38(%rbp)
movq (%r15), %rdi
callq 0x5496
movl %eax, %esi
xorl %edi, %edi
callq 0x23cc
movq %rax, -0x40(%rbp)
testq %rax, %rax
je 0x2dc2
movq (%r15), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rsi
cmpq %rsi, %rcx
je 0x2d33
movl $0x1, %ebx
movq %rax, %r14
subq %rcx, %rsi
sarq $0x3, %rsi
xorl %edi, %edi
callq 0x23cc
movq %r14, -0x30(%rbp)
movq 0x8(%r14), %rcx
movq (%rcx,%rax,8), %rax
movl %ebx, %ecx
cmpq %rcx, -0x40(%rbp)
jbe 0x2d3d
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rsi
incl %ebx
cmpq %rsi, %rcx
jne 0x2cfd
jmp 0x2d41
movq $0x0, -0x30(%rbp)
jmp 0x2d41
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %r14
movq 0x8(%r14), %rax
movq 0x10(%r14), %rsi
movl $0x1, %r15d
subq %rax, %rsi
sarq $0x3, %rsi
xorl %edi, %edi
callq 0x23cc
movq %rax, %r13
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %r12
movq -0x30(%rbp), %rdi
callq 0x5496
movl %eax, %ebx
movq %r12, %rdi
callq 0x5496
cmpl %eax, %ebx
je 0x2da6
movq 0x8(%r12), %rax
movq 0x10(%r12), %rsi
cmpq %rsi, %rax
je 0x2dc2
movl %r15d, %ecx
incl %r15d
movq %r12, %r14
cmpq %rcx, -0x40(%rbp)
ja 0x2d56
jmp 0x2dc2
movq (%r12), %rax
movq %r12, %rdi
callq *0x8(%rax)
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%r14), %rcx
movq %rax, (%rcx,%r13,8)
movq -0x38(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ALSchwalm[P]cppEvolve/include/cppEvolve/Genome/Tree/Mutator.hpp
// Function: void evolve::tree::mutator::randomNode<int>(evolve::tree::Tree<int>*, evolve::tree::TreeFactory<int> const&)
void randomNode(Tree<T>* tree, const TreeFactory<T>& factory) {
    auto treeDepth = tree->getDepth();
    auto depth = utils::random_uint(treeDepth);

    auto currentNode = tree->root;
    BaseNode<T>* prevNode = nullptr;

    for (unsigned int i = 0; i < depth; ++i) {
        prevNode = currentNode;
        auto nodeLocation =
            utils::random_uint(currentNode->getChildren().size());
        currentNode = currentNode->getChildren()[nodeLocation];

        if (currentNode->getChildren().empty()) {
            auto& children = prevNode->getChildren();
            delete currentNode;
            children[nodeLocation] = factory.createRandomTerminator();
            return;
        }
    }

    auto childValue = utils::random_uint(currentNode->getChildren().size());
    auto nodeDepth = currentNode->getChildren()[childValue]->getDepth();
    delete currentNode->getChildren()[childValue];

    currentNode->getChildren()[childValue] =
        factory.createRandomSubTree(nodeDepth - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, -0x30(%rbp)
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x5496
movl %eax, %esi
xorl %edi, %edi
callq 0x23cc
movq %rax, %r12
movq (%r14), %r13
movq 0x8(%r13), %rax
movq 0x10(%r13), %rsi
testq %r12, %r12
je 0x2e47
movl $0x1, %ebx
subq %rax, %rsi
sarq $0x3, %rsi
xorl %edi, %edi
callq 0x23cc
movq %rax, %r15
movq 0x8(%r13), %rax
movq (%rax,%r15,8), %r14
movq 0x8(%r14), %rax
movq 0x10(%r14), %rsi
cmpq %rsi, %rax
je 0x2e93
movl %ebx, %ecx
incl %ebx
movq %r14, %r13
cmpq %rcx, %r12
ja 0x2e13
jmp 0x2e4a
movq %r13, %r14
subq %rax, %rsi
sarq $0x3, %rsi
xorl %edi, %edi
callq 0x23cc
movq %rax, %r15
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x5496
movl %eax, %r12d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x2e7e
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
decl %r12d
movq -0x30(%rbp), %rdi
movl %r12d, %esi
callq 0x556e
jmp 0x2eac
addq $0x8, %r13
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq -0x30(%rbp), %rdi
callq 0x5514
movq %r13, %r14
movq (%r14), %rcx
movq %rax, (%rcx,%r15,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ALSchwalm[P]cppEvolve/include/cppEvolve/Genome/Tree/Tree.hpp
// Function: evolve::tree::Node<std::function<int (int, int)>>::clone() const
virtual BaseNode<typename Genome::result_type>* clone() const {
        auto node = new Node<Genome>(val, this->name, this->ID);
        for (auto child : this->children) {
            node->children.push_back(child->clone());
        }
        return node;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl $0x68, %edi
callq 0x2160
movq %rax, %rbx
leaq 0x48(%r14), %rsi
leaq -0x50(%rbp), %rdi
callq 0x4168
leaq 0x20(%r14), %rdx
movl 0x40(%r14), %ecx
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x407a
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x4301
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x8(%r14), %r12
movq 0x10(%r14), %r13
cmpq %r13, %r12
je 0x434f
movq %rbx, %r14
addq $0x8, %r14
leaq -0x30(%rbp), %r15
movq (%r12), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, -0x30(%rbp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x433b
movq %rax, (%rsi)
addq $0x8, 0x10(%rbx)
jmp 0x4346
movq %r14, %rdi
movq %r15, %rdx
callq 0x4510
addq $0x8, %r12
cmpq %r13, %r12
jne 0x4319
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x437f
movq %rax, %r14
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x438a
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x438a
movq %rax, %rdi
callq 0x35bd
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/ALSchwalm[P]cppEvolve/include/cppEvolve/Genome/Tree/Tree.hpp
// Function: evolve::tree::Terminator<std::function<int ()>>::clone() const
virtual BaseNode<typename Genome::result_type>* clone() const {
        auto node = new Terminator<Genome>(val, this->name, this->ID);
        for (auto child : this->children) {
            node->children.push_back(child->clone());
        }
        return node;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl $0x68, %edi
callq 0x2160
movq %rax, %rbx
leaq 0x48(%r14), %rsi
leaq -0x50(%rbp), %rdi
callq 0x5172
leaq 0x20(%r14), %rdx
movl 0x40(%r14), %ecx
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x50fc
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x52a7
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x8(%r14), %r12
movq 0x10(%r14), %r13
cmpq %r13, %r12
je 0x52f5
movq %rbx, %r14
addq $0x8, %r14
leaq -0x30(%rbp), %r15
movq (%r12), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, -0x30(%rbp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x52e1
movq %rax, (%rsi)
addq $0x8, 0x10(%rbx)
jmp 0x52ec
movq %r14, %rdi
movq %r15, %rdx
callq 0x4510
addq $0x8, %r12
cmpq %r13, %r12
jne 0x52bf
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5325
movq %rax, %r14
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x5330
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x5330
movq %rax, %rdi
callq 0x35bd
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/ALSchwalm[P]cppEvolve/include/cppEvolve/Genome/Tree/Tree.hpp
// Function: evolve::tree::BaseNode<int>::getDepth() const
unsigned int getDepth() const {
        unsigned int max = 0;
        for (auto child : children) {
            auto depth = child->getDepth();
            if (depth > max)
                max = depth;
        }
        return max + 1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %r15
cmpq %r15, %r14
je 0x54c9
xorl %ebx, %ebx
movq (%r14), %rdi
callq 0x5496
cmpl %ebx, %eax
cmoval %eax, %ebx
addq $0x8, %r14
cmpq %r15, %r14
jne 0x54af
incl %ebx
jmp 0x54ce
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ALSchwalm[P]cppEvolve/include/cppEvolve/Genome/Tree/Tree.hpp
// Function: evolve::tree::TreeFactory<int>::createRandomSubTree(unsigned int) const
BaseNode<Rtype>* createRandomSubTree(unsigned int depth = 5) const {

        BaseNode<Rtype>* root = nullptr;

        if (depth == 0) {
            root = createRandomTerminator();
        } else {
            root = createRandomNode();
            for (unsigned int i = 0; i < root->getNumChildren(); ++i) {
                root->getChildren().push_back(createRandomSubTree(depth - 1));
            }
        }
        return root;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x55fd
movl %esi, %r14d
movq %rbx, %rdi
callq 0x5614
movq %rax, %r15
movq (%rax), %rax
movq %r15, %rdi
callq *0x20(%rax)
testl %eax, %eax
je 0x55eb
decl %r14d
movq %r15, %r12
addq $0x8, %r12
xorl %r13d, %r13d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x556e
movq %rax, -0x30(%rbp)
movq 0x10(%r15), %rsi
cmpq 0x18(%r15), %rsi
je 0x55ce
movq %rax, (%rsi)
addq $0x8, 0x10(%r15)
jmp 0x55da
movq %r12, %rdi
leaq -0x30(%rbp), %rdx
callq 0x4510
incl %r13d
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
cmpl %eax, %r13d
jb 0x55ab
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5514
nop
// File: /workspace/github_cpp_makefile_star2_O3/ALSchwalm[P]cppEvolve/include/cppEvolve/Selector.hpp
// Function: void evolve::selector::details::topHelper<evolve::tree::Tree<int>*, 10ul, (evolve::Ordering)1>(std::vector<evolve::tree::Tree<int>*, std::allocator<evolve::tree::Tree<int>*>>&, std::function<float (evolve::tree::Tree<int>* const&)> const&, std::integral_constant<bool, true>)
void topHelper(std::vector<Genome>& population,
               const std::function<float(const Genome&)>& evaluator,
               std::true_type) {
    orderedSort(population, evaluator, Ord);

    auto location = population.begin();
    std::advance(location, Num);

    // Assume the pointer points to dynamically allocated memory
    for (auto iter = location; iter != population.end(); ++iter) {
        delete *iter;
    }

    population.erase(location, population.end());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edx
callq 0x5710
movq (%rbx), %r15
addq $0x50, %r15
cmpq 0x8(%rbx), %r15
je 0x5707
xorl %r12d, %r12d
movq (%r15,%r12), %r14
testq %r14, %r14
je 0x56e4
movq (%r14), %rdi
testq %rdi, %rdi
je 0x56e4
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
callq 0x2140
leaq (%r15,%r12), %rax
addq $0x8, %rax
addq $0x8, %r12
cmpq 0x8(%rbx), %rax
jne 0x56cd
testq %r12, %r12
je 0x5707
movq %r15, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ALSchwalm[P]cppEvolve/include/cppEvolve/Genome/Tree/Tree.hpp
// Function: std::ostream& evolve::tree::operator<<<int>(std::ostream&, evolve::tree::BaseNode<int> const&)
std::ostream& operator<<(std::ostream& out, const BaseNode<T>& node) {
    out << node.name;

    if (!node.children.empty()) {
        out << "(";
        for (unsigned int i = 0; i < node.children.size() - 1; ++i)
            out << *(node.children[i]) << ", ";

        out << *node.children[node.children.size() - 1] << ")";
    }
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %rsi
movq 0x28(%r14), %rdx
callq 0x2180
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
je 0x6ccc
leaq 0x75b(%rip), %rsi       # 0x739d
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2180
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
jne 0x6c64
xorl %edx, %edx
jmp 0x6cac
movl $0x1, %r12d
xorl %ecx, %ecx
leaq 0x7e0(%rip), %r15       # 0x7453
movq (%rax,%rcx,8), %rsi
movq %rbx, %rdi
callq 0x6c0f
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2180
movl %r12d, %ecx
movq 0x8(%r14), %rax
movq 0x10(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
decq %rdx
incl %r12d
cmpq %rcx, %rdx
ja 0x6c73
movq (%rax,%rdx,8), %rsi
movq %rbx, %rdi
callq 0x6c0f
leaq 0x723(%rip), %rsi       # 0x73e2
movl $0x1, %edx
movq %rax, %rdi
callq 0x2180
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dannye[P]jed/src/decoder.cpp
// Function: readQuantizationTable(BitReader&, JPGImage*)
void readQuantizationTable(BitReader& bitReader, JPGImage* const image) {
    std::cout << "Reading DQT Marker\n";
    int length = bitReader.readWord();
    length -= 2;

    while (length > 0) {
        byte tableInfo = bitReader.readByte();
        length -= 1;
        byte tableID = tableInfo & 0x0F;

        if (tableID > 3) {
            std::cout << "Error - Invalid quantization table ID: " << (uint)tableID << '\n';
            image->valid = false;
            return;
        }
        QuantizationTable& qTable = image->quantizationTables[tableID];
        qTable.set = true;

        if (tableInfo >> 4 != 0) {
            for (uint i = 0; i < 64; ++i) {
                qTable.table[zigZagMap[i]] = bitReader.readWord();
            }
            length -= 128;
        }
        else {
            for (uint i = 0; i < 64; ++i) {
                qTable.table[zigZagMap[i]] = bitReader.readByte();
            }
            length -= 64;
        }
    }

    if (length != 0) {
        std::cout << "Error - DQT invalid\n";
        image->valid = false;
        return;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbp
movq %rdi, %r14
movq 0x7802(%rip), %rdi      # 0x9fd8
leaq 0x4ad9(%rip), %rsi      # 0x72b6
movl $0x13, %edx
callq 0x2130
movb $0x0, 0x1(%r14)
leaq 0x8(%r14), %r15
movq %r15, %rdi
callq 0x2140
movl %eax, %r12d
shll $0x8, %r12d
movq %r15, %rdi
callq 0x2140
leal (%rax,%r12), %r13d
addl $-0x2, %r13d
testl %r13d, %r13d
jle 0x28d7
leaq 0x48d1(%rip), %rbx      # 0x70f0
movq %rbp, 0x10(%rsp)
movb $0x0, 0x1(%r14)
movq %r15, %rdi
callq 0x2140
movl %eax, %r12d
andb $0xf, %al
cmpb $0x4, %al
jae 0x28f1
movl %r13d, 0xc(%rsp)
movzbl %al, %eax
movl %eax, %ecx
shll $0x8, %ecx
leal (%rcx,%rax,4), %eax
leaq (%rax,%rbp), %r13
movb $0x1, 0x100(%rbp,%rax)
cmpb $0x10, %r12b
jae 0x288d
xorl %r12d, %r12d
movb $0x0, 0x1(%r14)
movq %r15, %rdi
callq 0x2140
movzbl %al, %eax
movzbl (%r12,%rbx), %ecx
movl %eax, (%r13,%rcx,4)
incq %r12
cmpq $0x40, %r12
jne 0x2863
movl $0xffffffbf, %eax       # imm = 0xFFFFFFBF
jmp 0x28c9
xorl %r12d, %r12d
movb $0x0, 0x1(%r14)
movq %r15, %rdi
callq 0x2140
movl %eax, %ebp
shll $0x8, %ebp
movq %r15, %rdi
callq 0x2140
addl %ebp, %eax
movzbl (%r12,%rbx), %ecx
movl %eax, (%r13,%rcx,4)
incq %r12
cmpq $0x40, %r12
jne 0x2890
movl $0xffffff7f, %eax       # imm = 0xFFFFFF7F
movq 0x10(%rsp), %rbp
movl 0xc(%rsp), %r13d
addl %eax, %r13d
jg 0x2824
testl %r13d, %r13d
je 0x2937
movq 0x76f5(%rip), %rdi      # 0x9fd8
leaq 0x49e0(%rip), %rsi      # 0x72ca
movl $0x14, %edx
jmp 0x292b
andl $0xf, %r12d
movq 0x76dc(%rip), %r14      # 0x9fd8
leaq 0x4976(%rip), %rsi      # 0x7279
movl $0x27, %edx
movq %r14, %rdi
callq 0x2130
movq %r14, %rdi
movq %r12, %rsi
callq 0x20a0
leaq 0xb(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2130
movb $0x0, 0x2088(%rbp)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dannye[P]jed/src/decoder.cpp
// Function: readRestartInterval(BitReader&, JPGImage*)
void readRestartInterval(BitReader& bitReader, JPGImage* const image) {
    std::cout << "Reading DRI Marker\n";
    uint length = bitReader.readWord();

    image->restartInterval = bitReader.readWord();
    if (length - 4 != 0) {
        std::cout << "Error - DRI invalid\n";
        image->valid = false;
        return;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x69aa(%rip), %rdi      # 0x9fd8
leaq 0x4012(%rip), %rsi      # 0x7647
movl $0x13, %edx
callq 0x2130
xorl %r13d, %r13d
movb %r13b, 0x1(%r14)
leaq 0x8(%r14), %r15
movq %r15, %rdi
callq 0x2140
movl %eax, %ebp
shll $0x8, %ebp
movq %r15, %rdi
callq 0x2140
movl %eax, %r12d
addl %ebp, %r12d
movb %r13b, 0x1(%r14)
movq %r15, %rdi
callq 0x2140
movl %eax, %ebp
shll $0x8, %ebp
movq %r15, %rdi
callq 0x2140
addl %ebp, %eax
movl %eax, 0x2078(%rbx)
cmpl $0x4, %r12d
je 0x36ab
movq 0x6945(%rip), %rdi      # 0x9fd8
leaq 0x3fc1(%rip), %rsi      # 0x765b
movl $0x14, %edx
callq 0x2130
movb $0x0, 0x2088(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dannye[P]jed/src/decoder.cpp
// Function: readAPPN(BitReader&, JPGImage*)
void readAPPN(BitReader& bitReader, JPGImage* const image) {
    std::cout << "Reading APPN Marker\n";
    uint length = bitReader.readWord();
    if (length < 2) {
        std::cout << "Error - APPN invalid\n";
        image->valid = false;
        return;
    }

    for (uint i = 0; i < length - 2; ++i) {
        bitReader.readByte();
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x6909(%rip), %rdi      # 0x9fd8
leaq 0x3f9a(%rip), %rsi      # 0x7670
movl $0x14, %edx
callq 0x2130
movb $0x0, 0x1(%rbx)
leaq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0x2140
movl %eax, %r12d
shll $0x8, %r12d
movq %r15, %rdi
callq 0x2140
movl %eax, %ebp
addl %r12d, %ebp
cmpl $0x2, %ebp
jae 0x372b
movq 0x68c8(%rip), %rdi      # 0x9fd8
leaq 0x3f6e(%rip), %rsi      # 0x7685
movl $0x15, %edx
callq 0x2130
movb $0x0, 0x2088(%r14)
jmp 0x3740
addl $-0x2, %ebp
je 0x3740
movb $0x0, 0x1(%rbx)
movq %r15, %rdi
callq 0x2140
decl %ebp
jne 0x3730
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dannye[P]jed/src/decoder.cpp
// Function: readComment(BitReader&, JPGImage*)
void readComment(BitReader& bitReader, JPGImage* const image) {
    std::cout << "Reading COM Marker\n";
    uint length = bitReader.readWord();
    if (length < 2) {
        std::cout << "Error - COM invalid\n";
        image->valid = false;
        return;
    }

    for (uint i = 0; i < length - 2; ++i) {
        bitReader.readByte();
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x687a(%rip), %rdi      # 0x9fd8
leaq 0x3f36(%rip), %rsi      # 0x769b
movl $0x13, %edx
callq 0x2130
movb $0x0, 0x1(%rbx)
leaq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0x2140
movl %eax, %r12d
shll $0x8, %r12d
movq %r15, %rdi
callq 0x2140
movl %eax, %ebp
addl %r12d, %ebp
cmpl $0x2, %ebp
jae 0x37ba
movq 0x6839(%rip), %rdi      # 0x9fd8
leaq 0x3f09(%rip), %rsi      # 0x76af
movl $0x14, %edx
callq 0x2130
movb $0x0, 0x2088(%r14)
jmp 0x37cf
addl $-0x2, %ebp
je 0x37cf
movb $0x0, 0x1(%rbx)
movq %r15, %rdi
callq 0x2140
decl %ebp
jne 0x37bf
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dannye[P]jed/src/decoder.cpp
// Function: getNextSymbol(BitReader&, HuffmanTable const&)
byte getNextSymbol(BitReader& bitReader, const HuffmanTable& hTable) {
    uint currentCode = 0;
    for (uint i = 0; i < 16; ++i) {
        int bit = bitReader.readBit();
        if (bit == -1) {
            return -1;
        }
        currentCode = (currentCode << 1) | bit;
        for (uint j = hTable.offsets[i]; j < hTable.offsets[i + 1]; ++j) {
            if (currentCode == hTable.codes[j]) {
                return hTable.symbols[j];
            }
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x638a
movl %eax, %ecx
movb $-0x1, %al
cmpl $-0x1, %ecx
je 0x4bde
movl %ebp, %edx
addl %ebp, %edx
movl %ecx, %ebp
orl %edx, %ebp
movzbl (%rbx,%r15), %ecx
movzbl 0x1(%rbx,%r15), %edx
cmpb %dl, %cl
jae 0x4bcf
cmpl 0xc4(%rbx,%rcx,4), %ebp
je 0x4bda
incq %rcx
cmpq %rcx, %rdx
jne 0x4bbe
incq %r15
cmpq $0x10, %r15
jne 0x4b96
jmp 0x4bde
movb 0x11(%rbx,%rcx), %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dannye[P]jed/src/decoder.cpp
// Function: dequantize(JPGImage const*)
void dequantize(const JPGImage* const image) {
    for (uint y = 0; y < image->blockHeight; y += image->verticalSamplingFactor) {
        for (uint x = 0; x < image->blockWidth; x += image->horizontalSamplingFactor) {
            for (uint i = 0; i < image->numComponents; ++i) {
                const ColorComponent& component = image->colorComponents[i];
                for (uint v = 0; v < component.verticalSamplingFactor; ++v) {
                    for (uint h = 0; h < component.horizontalSamplingFactor; ++h) {
                        dequantizeBlockComponent(image->quantizationTables[component.quantizationTableID],
                            image->blocks[(y + v) * image->blockWidthReal + (x + h)][i]);
                    }
                }
            }
        }
    }
}

// Assembly:
movl 0x208c(%rdi), %esi
testl %esi, %esi
je 0x548f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x2050(%rdi), %rax
movq %rax, -0x8(%rsp)
movzbl 0x209d(%rdi), %eax
movl %eax, -0x18(%rsp)
movl 0x2090(%rdi), %ecx
xorl %edx, %edx
movl %ecx, %r8d
testl %r8d, %r8d
je 0x5476
movzbl 0x2070(%rdi), %eax
movq %rax, -0x10(%rsp)
movzbl 0x209c(%rdi), %eax
movl %eax, -0x14(%rsp)
xorl %r9d, %r9d
cmpq $0x0, -0x10(%rsp)
je 0x545d
xorl %r10d, %r10d
leaq (,%r10,8), %r11
subq %r10, %r11
movq -0x8(%rsp), %rax
movzbl 0x1(%rax,%r11), %ebx
testl %ebx, %ebx
je 0x5449
addq -0x8(%rsp), %r11
movzbl (%r11), %ebp
xorl %r14d, %r14d
testl %ebp, %ebp
je 0x543d
movzbl 0x2(%r11), %ecx
movl %ecx, %esi
shll $0x8, %esi
leaq (%rsi,%rcx,4), %r15
addq %rdi, %r15
movq 0x2080(%rdi), %r12
leal (%r14,%rdx), %r13d
xorl %ecx, %ecx
movl 0x2098(%rdi), %esi
imull %r13d, %esi
addl %ecx, %esi
addl %r9d, %esi
leaq (%rsi,%rsi,2), %r8
shlq $0x8, %r8
addq %r12, %r8
testl %r10d, %r10d
je 0x541f
cmpl $0x2, %r10d
je 0x5413
cmpl $0x1, %r10d
jne 0x541c
addq $0x100, %r8             # imm = 0x100
jmp 0x541f
addq $0x200, %r8             # imm = 0x200
jmp 0x541f
xorl %r8d, %r8d
xorl %esi, %esi
movl (%r8,%rsi,4), %eax
imull (%r15,%rsi,4), %eax
movl %eax, (%r8,%rsi,4)
incq %rsi
cmpq $0x40, %rsi
jne 0x5421
incl %ecx
cmpl %ebp, %ecx
jne 0x53df
incl %r14d
cmpl %ebx, %r14d
jne 0x53bd
incq %r10
cmpq -0x10(%rsp), %r10
jne 0x5393
movl 0x2090(%rdi), %ecx
addl -0x14(%rsp), %r9d
cmpl %ecx, %r9d
jb 0x5384
movl 0x208c(%rdi), %esi
movl %ecx, %r8d
jmp 0x5479
xorl %r8d, %r8d
addl -0x18(%rsp), %edx
cmpl %esi, %edx
jb 0x5361
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dannye[P]jed/src/decoder.cpp
// Function: YCbCrToRGBBlock(Block&, Block const&, unsigned int, unsigned int, unsigned int, unsigned int)
void YCbCrToRGBBlock(Block& yBlock, const Block& cbcrBlock, const uint vSamp, const uint hSamp, const uint v, const uint h) {
    for (uint y = 7; y < 8; --y) {
        for (uint x = 7; x < 8; --x) {
            const uint pixel = y * 8 + x;
            const uint cbcrPixelRow = y / vSamp + 4 * v;
            const uint cbcrPixelColumn = x / hSamp + 4 * h;
            const uint cbcrPixel = cbcrPixelRow * 8 + cbcrPixelColumn;
            int r = yBlock.y[pixel]                                    + 1.402f * cbcrBlock.cr[cbcrPixel] + 128;
            int g = yBlock.y[pixel] - 0.344f * cbcrBlock.cb[cbcrPixel] - 0.714f * cbcrBlock.cr[cbcrPixel] + 128;
            int b = yBlock.y[pixel] + 1.772f * cbcrBlock.cb[cbcrPixel]                                    + 128;
            if (r < 0)   r = 0;
            if (r > 255) r = 255;
            if (g < 0)   g = 0;
            if (g > 255) g = 255;
            if (b < 0)   b = 0;
            if (b > 255) b = 255;
            yBlock.r[pixel] = r;
            yBlock.g[pixel] = g;
            yBlock.b[pixel] = b;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r11d
shll $0x5, %r8d
leal (%r8,%r9,4), %r8d
addq $0xfc, %rdi
movl $0x7, %r9d
xorl %ebx, %ebx
movss 0x1603(%rip), %xmm0     # 0x7130
movss 0x15ff(%rip), %xmm1     # 0x7134
movss 0x15fb(%rip), %xmm2     # 0x7138
movss 0x15f7(%rip), %xmm3     # 0x713c
movss 0x15f3(%rip), %xmm4     # 0x7140
movl $0xff, %ebp
movl %r9d, %eax
xorl %edx, %edx
divl %r11d
leal (%r8,%rax,8), %r14d
movq %rdi, %r15
movl $0x7, %r10d
movl %r10d, %eax
xorl %edx, %edx
divl %ecx
xorps %xmm5, %xmm5
cvtsi2ssl (%r15), %xmm5
addl %r14d, %eax
xorps %xmm6, %xmm6
cvtsi2ssl 0x200(%rsi,%rax,4), %xmm6
movaps %xmm6, %xmm7
mulss %xmm0, %xmm7
addss %xmm5, %xmm7
addss %xmm1, %xmm7
cvttss2si %xmm7, %edx
xorps %xmm7, %xmm7
cvtsi2ssl 0x100(%rsi,%rax,4), %xmm7
movaps %xmm7, %xmm8
mulss %xmm2, %xmm8
addss %xmm5, %xmm8
mulss %xmm3, %xmm6
addss %xmm8, %xmm6
addss %xmm1, %xmm6
cvttss2si %xmm6, %eax
mulss %xmm4, %xmm7
addss %xmm5, %xmm7
addss %xmm1, %xmm7
cvttss2si %xmm7, %r12d
testl %edx, %edx
cmovlel %ebx, %edx
cmpl %ebp, %edx
cmovgel %ebp, %edx
testl %eax, %eax
cmovlel %ebx, %eax
cmpl %ebp, %eax
cmovgel %ebp, %eax
testl %r12d, %r12d
cmovlel %ebx, %r12d
cmpl %ebp, %r12d
cmovgel %ebp, %r12d
movl %edx, (%r15)
movl %eax, 0x100(%r15)
movl %r12d, 0x200(%r15)
decq %r10
addq $-0x4, %r15
cmpq $0x8, %r10
jb 0x5b67
decq %r9
addq $-0x20, %rdi
cmpq $0x8, %r9
jb 0x5b52
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dannye[P]jed/src/decoder.cpp
// Function: YCbCrToRGB(JPGImage const*)
void YCbCrToRGB(const JPGImage* const image) {
    const uint vSamp = image->verticalSamplingFactor;
    const uint hSamp = image->horizontalSamplingFactor;
    for (uint y = 0; y < image->blockHeight; y += vSamp) {
        for (uint x = 0; x < image->blockWidth; x += hSamp) {
            const Block& cbcrBlock = image->blocks[y * image->blockWidthReal + x];
            for (uint v = vSamp - 1; v < vSamp; --v) {
                for (uint h = hSamp - 1; h < hSamp; --h) {
                    Block& yBlock = image->blocks[(y + v) * image->blockWidthReal + (x + h)];
                    YCbCrToRGBBlock(yBlock, cbcrBlock, vSamp, hSamp, v, h);
                }
            }
        }
    }
}

// Assembly:
movl 0x208c(%rdi), %r9d
testl %r9d, %r9d
je 0x5d74
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r12
movzbl 0x209d(%rdi), %r15d
movzbl 0x209c(%rdi), %r14d
leal -0x1(%r15), %esi
leal -0x1(%r14), %eax
movl %eax, 0x18(%rsp)
movl 0x2090(%rdi), %eax
movl $0x0, 0xc(%rsp)
movl %esi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl %eax, %esi
testl %esi, %esi
je 0x5d4b
xorl %r9d, %r9d
testb %r15b, %r15b
je 0x5d33
movl 0x2098(%r12), %eax
imull 0xc(%rsp), %eax
addl %r9d, %eax
leaq (%rax,%rax,2), %rbp
shlq $0x8, %rbp
addq 0x2080(%r12), %rbp
movl 0x10(%rsp), %edi
movl 0x14(%rsp), %ebx
movq %r9, 0x20(%rsp)
movl 0x18(%rsp), %eax
movl %eax, %r13d
testb %r14b, %r14b
movl %edi, 0x1c(%rsp)
je 0x5d22
movl 0x2098(%r12), %eax
imull %edi, %eax
movq 0x20(%rsp), %rdi
addl %r13d, %edi
addl %edi, %eax
leaq (%rax,%rax,2), %rdi
shlq $0x8, %rdi
addq 0x2080(%r12), %rdi
movq %rbp, %rsi
movl %r15d, %edx
movl %r14d, %ecx
movl %ebx, %r8d
movl %r13d, %r9d
callq 0x5b03
movl 0x1c(%rsp), %edi
movq 0x20(%rsp), %r9
decl %r13d
cmpl %r14d, %r13d
jb 0x5cd8
decl %ebx
decl %edi
cmpl %r15d, %ebx
jb 0x5cc8
movl 0x2090(%r12), %eax
addl %r14d, %r9d
cmpl %eax, %r9d
jb 0x5c92
movl 0x208c(%r12), %r9d
movl %eax, %esi
jmp 0x5d4d
xorl %esi, %esi
movl 0xc(%rsp), %edi
addl %r15d, %edi
addl %r15d, 0x10(%rsp)
movl %edi, 0xc(%rsp)
cmpl %r9d, %edi
jb 0x5c87
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dannye[P]jed/src/decoder.cpp
// Function: BitReader::readBit()
uint readBit() {
        if (nextBit == 0) {
            if (!hasBits()) {
                return -1;
            }
            nextByte = inFile.get();
            while (nextByte == 0xFF) {
                if (!hasBits()) {
                    return -1;
                }
                byte marker = inFile.peek();
                // ignore multiple 0xFF's in a row
                while (marker == 0xFF) {
                    inFile.get();
                    if (!hasBits()) {
                        return -1;
                    }
                    marker = inFile.peek();
                }
                // literal 0xFF's are encoded in the bitstream as 0xFF00
                if (marker == 0x00) {
                    inFile.get();
                    break;
                }
                // restart marker
                else if (marker >= RST0 && marker <= RST7) {
                    inFile.get();
                    nextByte = inFile.get();
                }
                else {
                    std::cout << "Error - Invalid marker: 0x" << std::hex << (uint)marker << std::dec << '\n';
                    return -1;
                }
            }
        }
        uint bit = (nextByte >> (7 - nextBit)) & 1;
        nextBit = (nextBit + 1) % 8;
        return bit;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
cmpb $0x0, 0x1(%rdi)
je 0x63be
movzbl (%r14), %eax
movb 0x1(%r14), %cl
movb $0x7, %dl
subb %cl, %dl
movzbl %dl, %edx
xorl %ebx, %ebx
btl %edx, %eax
setb %bl
incb %cl
andb $0x7, %cl
movb %cl, 0x1(%r14)
jmp 0x63d3
movq 0x8(%r14), %rax
movq -0x18(%rax), %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testb $0x5, 0x28(%r14,%rax)
je 0x63df
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%r14), %r15
movq %r15, %rdi
callq 0x2140
movb %al, (%r14)
cmpb $-0x1, %al
jne 0x639c
jmp 0x63fc
movq %r15, %rdi
callq 0x2140
movq 0x8(%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%r14,%rax)
jne 0x63d3
movq %r15, %rdi
callq 0x2070
cmpb $-0x1, %al
je 0x63f4
movzbl %al, %ecx
testl %ecx, %ecx
je 0x6439
movl %eax, %ecx
andl $0xf8, %ecx
cmpl $0xd0, %ecx
jne 0x6446
movq %r15, %rdi
callq 0x2140
jmp 0x63e3
movq %r15, %rdi
callq 0x2140
jmp 0x639c
movzbl %al, %r14d
movq 0x3b87(%rip), %r15      # 0x9fd8
leaq 0x1552(%rip), %rsi      # 0x79aa
movl $0x1a, %edx
movq %r15, %rdi
callq 0x2130
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x20a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
leaq 0xf(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2130
jmp 0x63d3
// File: /workspace/github_cpp_makefile_star2_O3/Infinidat[P]slimfastq/config.cpp
// Function: croak(char const*, ...)
void croak(const char *format, ...) {
    va_list args;
    va_start(args, format);
    fprintf(stderr, "slimfastq: %s %s: ",
            ( conf.encode ? "encoding" : "decoding"),
            conf.get_info("orig.filename"));

    // if (errno)
    //     fprintf(stderr, "err=%s", strerror(errno));

    vfprintf(stderr, format, args);
    fprintf(stderr, "\n");

    exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x2367
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rdi, 0x10(%r14)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq 0xec42(%rip), %r13      # 0x10fd0
movq (%r13), %r15
leaq 0x10f87(%rip), %rax     # 0x13320
leaq 0x8d7f(%rip), %rcx      # 0xb11f
leaq 0x8d81(%rip), %r12      # 0xb128
cmpb $0x0, 0xc(%rax)
cmovneq %rcx, %r12
leaq 0x8d7b(%rip), %rsi      # 0xb131
callq 0x4340
leaq 0x8d4a(%rip), %rsi      # 0xb10c
movq %r15, %rdi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2250
movq (%r13), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2240
movq (%r13), %rsi
pushq $0xa
popq %rdi
callq 0x2220
pushq $0x1
popq %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/Infinidat[P]slimfastq/filer.cpp
// Function: OneFile::do_confess() const
void do_confess() const {
        // i: 'name'       : size  : first : node
        fprintf(stderr, " i: name      : NODES count    : 1st    : 2nd\n");
        for (UINT32 i = 0;
             i < next_findex;
             i++) {
            char name[10];
            strncpy(name, (char*)&files[i].name, 8);
            fprintf(stderr, "%2d: %-10s: %-15lld: %d:\t: %d\n",
                    i, (i? name : "<info>"), files[i].size, files[i].first, files[i].node);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0xeae2(%rip), %rbp      # 0x10fd0
movq (%rbp), %rcx
leaq 0x983f(%rip), %rdi      # 0xbd38
pushq $0x2e
popq %rsi
pushq $0x1
popq %rdx
callq 0x22e0
cmpq $0x0, 0x2010(%rbx)
je 0x2575
leaq 0xe(%rsp), %r14
leaq 0x984d(%rip), %r12      # 0xbd67
xorl %eax, %eax
xorl %r13d, %r13d
imulq $0x18, %rax, %r15
leaq (%rbx,%r15), %rsi
movq %r14, %rdi
pushq $0x8
popq %rdx
callq 0x2100
testl %r13d, %r13d
movq %r14, %rcx
leaq 0x9847(%rip), %rax      # 0xbd86
cmoveq %rax, %rcx
movq (%rbp), %rdi
movq 0x8(%rbx,%r15), %r8
movl 0x10(%rbx,%r15), %r9d
movl 0x14(%rbx,%r15), %eax
movl %eax, (%rsp)
movq %r12, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0x2250
incl %r13d
movq %r13, %rax
cmpq %r13, 0x2010(%rbx)
ja 0x251f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Infinidat[P]slimfastq/bfiler.cpp
// Function: BFileSave::~BFileSave()
BFileSave::~BFileSave() {
    if (bcnt and filer)
        ranger->put(&rc, bmap);
    rc.done();
    DELETE(filer);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x1(%rdi)
je 0x36d8
cmpq $0x0, 0x38(%rbx)
je 0x36d8
movq 0x8(%rbx), %rdi
leaq 0x10(%rbx), %rsi
movzbl (%rbx), %edx
callq 0x3842
leaq 0x10(%rbx), %rdi
callq 0x3f6c
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x36ff
movq %r14, %rdi
callq 0x5cce
movl $0x4040, %esi           # imm = 0x4040
movq %r14, %rdi
callq 0x21c0
movq $0x0, 0x38(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3612
movq %rax, %rdi
callq 0x3f61
// File: /workspace/github_cpp_makefile_star2_O3/Infinidat[P]slimfastq/bfiler.cpp
// Function: BFileSave::putb(bool)
void BFileSave::putb(bool bit) {
    bmap |= ((!!bit)<<bcnt++);
    rarely_if (bcnt == 8) {
        ranger->put(&rc, bmap);
        bmap = bcnt = 0;
    }
}

// Assembly:
movb 0x1(%rdi), %cl
leal 0x1(%rcx), %eax
movb %al, 0x1(%rdi)
shll %cl, %esi
orb (%rdi), %sil
movb %sil, (%rdi)
cmpb $0x8, %al
je 0x3734
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x10(%rbx), %rax
movzbl %sil, %edx
movq %rax, %rsi
callq 0x3842
movw $0x0, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Infinidat[P]slimfastq/bfiler.cpp
// Function: BFileLoad::getb()
bool BFileLoad::getb() {
    rarely_if(bcnt == 0) {
        bcnt = 8;
        bmap = ranger->get(&rc);
    }
    return !! (bmap & (0x100>> bcnt--));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb 0x1(%rdi), %cl
testb %cl, %cl
je 0x382a
movb (%rbx), %al
movzbl %al, %eax
leal -0x1(%rcx), %edx
shll %cl, %eax
movb %dl, 0x1(%rbx)
shrl $0x8, %eax
andl $0x1, %eax
popq %rbx
retq
movb $0x8, 0x1(%rbx)
movq 0x8(%rbx), %rdi
leaq 0x10(%rbx), %rsi
callq 0x406a
movb %al, (%rbx)
movb 0x1(%rbx), %cl
jmp 0x3817
// File: /workspace/github_cpp_makefile_star2_O3/Infinidat[P]slimfastq/./coder.hpp
// Function: RCoder::done()
void done() {
        // Allow explicit 'done' in case we wish not FilerSave close before this call
        if (m_out) {
            for (int i=0; i<8; i++) {
                m_out->put(low >> 56);
                low <<= 8;
            }
            m_out = NULL;
        }
    }

// Assembly:
cmpq $0x0, 0x20(%rdi)
je 0x3fe1
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
movl $0x8, %ebp
movq 0x20(%rbx), %r14
movq 0x2018(%r14), %rax
cmpq $0x2000, %rax           # imm = 0x2000
jae 0x3fbc
shrq $0x38, %r15
leaq 0x1(%rax), %rcx
movq %rcx, 0x2018(%r14)
movb %r15b, 0x9(%r14,%rax)
movq (%rbx), %r15
shlq $0x8, %r15
movq %r15, (%rbx)
decl %ebp
jne 0x3f85
jmp 0x3fcf
movq %r14, %rdi
xorl %esi, %esi
callq 0x5cfe
movq 0x2018(%r14), %rax
jmp 0x3f98
movq $0x0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Infinidat[P]slimfastq/./coder.hpp
// Function: RCoder::init(FilerLoad*)
void init(FilerLoad* f_in) {
        m_in  = f_in;
        m_out = NULL;
        low=0;
        range=(UINT32)-1;
        code = 0;               // happy compiler
        for (int i=0; i<8; i++)
            code = (code<<8) | m_in->get();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movl $0xffffffff, 0x10(%rdi) # imm = 0xFFFFFFFF
movl $0x8, %ebp
xorl %r15d, %r15d
movq 0x18(%rbx), %r14
movq 0x2020(%r14), %rax
cmpq 0x2018(%r14), %rax
jbe 0x4055
cmpb $0x1, 0x8(%r14)
jne 0x4042
movq 0x2018(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x2018(%r14)
movzbl 0x9(%r14,%rax), %eax
jmp 0x4044
xorl %eax, %eax
shlq $0x8, %r15
orq %rax, %r15
movq %r15, 0x8(%rbx)
decl %ebp
jne 0x400d
jmp 0x405f
movq %r14, %rdi
callq 0x5f18
jmp 0x4021
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Infinidat[P]slimfastq/./power_ranger.hpp
// Function: PowerRanger::get(RCoder*)
UINT16 get(RCoder *rc) {

        UINT32 vtot = total + NSYM; // - iend;
        UINT32 sumf = 0;
        UINT32 i;

        UINT32 prob = rc->GetFreq(vtot);
        for ( i = 0;
              i < NSYM;
              i ++ ) {

            rarely_if(iend    == i)
                syms[ iend++ ] = i;

            if (sumf +  freq[i] + 1 <= prob)
                sumf += freq[i] + 1;
            else
                break;
        }
        rc->Decode(sumf, freq[i]+1, vtot);

        return update_freq(i);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r8
movq %rdi, %rbx
movl $0x100, %ecx            # imm = 0x100
addl (%rdi), %ecx
movl 0x10(%rsi), %eax
xorl %edi, %edi
xorl %edx, %edx
divl %ecx
movl %eax, %esi
movl %eax, 0x10(%r8)
movq 0x8(%r8), %rax
xorl %edx, %edx
divq %rsi
movzwl 0x204(%rbx), %edx
xorl %r9d, %r9d
movzwl %dx, %esi
cmpq %rsi, %rdi
je 0x40c4
movzwl 0x4(%rbx,%rdi,2), %esi
addl %r9d, %esi
incl %esi
cmpl %eax, %esi
ja 0x40d8
incq %rdi
movl %esi, %r9d
cmpq $0x100, %rdi            # imm = 0x100
jne 0x409d
jmp 0x40dd
leal 0x1(%rsi), %edx
movw %dx, 0x204(%rbx)
movb %dil, 0x207(%rbx,%rsi)
jmp 0x40a5
movl %r9d, %esi
jmp 0x40e2
movl $0x100, %edi            # imm = 0x100
movl %edi, %r14d
movzwl 0x4(%rbx,%r14,2), %edx
incl %edx
movq %r8, %rdi
callq 0x427a
movzwl 0x4(%rbx,%r14,2), %eax
cmpl $0x7fd2, %eax           # imm = 0x7FD2
ja 0x4147
movl (%rbx), %ecx
addl $0xe, %eax
movw %ax, 0x4(%rbx,%r14,2)
addl $0xe, %ecx
movl %ecx, (%rbx)
testq %r14, %r14
je 0x4134
movb 0x206(%rbx), %cl
incb %cl
movb %cl, 0x206(%rbx)
testb $0xf, %cl
jne 0x4134
movslq %r14d, %rcx
cmpw 0x2(%rbx,%rcx,2), %ax
ja 0x4195
movb 0x207(%rbx,%r14), %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testq %r14, %r14
jne 0x4158
movl %eax, %ecx
addl $0x100, %ecx            # imm = 0x100
cmpl (%rbx), %ecx
ja 0x4134
cmpw $0x0, 0x204(%rbx)
je 0x418e
xorl %eax, %eax
xorl %ecx, %ecx
movzwl 0x4(%rbx,%rax,2), %edx
shrl %edx
movw %dx, 0x4(%rbx,%rax,2)
addl %edx, %ecx
incq %rax
movzwl 0x204(%rbx), %edx
cmpq %rdx, %rax
jb 0x4166
movzwl 0x4(%rbx,%r14,2), %eax
jmp 0x4104
xorl %ecx, %ecx
jmp 0x4104
movb 0x207(%rbx,%r14), %al
movb 0x206(%rbx,%rcx), %dl
movb %dl, 0x207(%rbx,%r14)
movb %al, 0x206(%rbx,%rcx)
movd 0x2(%rbx,%rcx,2), %xmm0
pshuflw $0xe1, %xmm0, %xmm0     # xmm0 = xmm0[1,0,2,3,4,5,6,7]
movd %xmm0, 0x2(%rbx,%rcx,2)
jmp 0x413c
nop