LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::replaceNeighbor(unsigned int const&, unsigned int const&, unsigned int const&)
void Graph::replaceNeighbor(const uint32_t &node, const uint32_t &oldNeighbor, const uint32_t &newNeighbor) {
    uint32_t offset;
    offset = findEdgeOffset(node, oldNeighbor);
    assert(offset != NONE);
    uint32_t pos = (!mapping ? node : idToPos->at(node));
    uint32_t endOffset = (pos == nodeIndex.size()-1 ? edgeBuffer->size() : nodeIndex[pos+1].offset);
    auto it = edgeBuffer->begin();
    move(it + offset + 1, it + endOffset, it + offset);
    (*edgeBuffer)[endOffset-1] = newNeighbor;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0x19890
movl %eax, 0x64(%rsp)
cmpl $-0x1, 0x64(%rsp)
je 0x48e7
jmp 0x4906
leaq 0x41837(%rip), %rdi     # 0x46125
leaq 0x41745(%rip), %rsi     # 0x4603a
movl $0x139, %edx            # imm = 0x139
leaq 0x41833(%rip), %rcx     # 0x46134
callq 0x2110
movq 0x20(%rsp), %rax
testb $0x1, 0x3c(%rax)
jne 0x491e
movq 0x78(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
jmp 0x4937
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rdi
movq 0x78(%rsp), %rsi
callq 0x188b0
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x60(%rsp)
movl 0x60(%rsp), %eax
movq %rax, 0x10(%rsp)
callq 0x18830
movq %rax, %rcx
movq 0x10(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x4978
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x188e0
movq %rax, 0x8(%rsp)
jmp 0x4994
movq 0x20(%rsp), %rdi
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x19050
movl (%rax), %eax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movl %ecx, 0x5c(%rsp)
movq 0x18(%rax), %rdi
callq 0x19b50
movq %rax, 0x50(%rsp)
movl 0x64(%rsp), %eax
movl %eax, %esi
leaq 0x50(%rsp), %rdi
callq 0x19bf0
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %rdi
movl $0x1, %esi
callq 0x19bf0
movq %rax, 0x48(%rsp)
movl 0x5c(%rsp), %eax
movl %eax, %esi
leaq 0x50(%rsp), %rdi
callq 0x19bf0
movq %rax, 0x38(%rsp)
movl 0x64(%rsp), %eax
movl %eax, %esi
leaq 0x50(%rsp), %rdi
callq 0x19bf0
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x19b80
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq 0x68(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x4(%rsp)
movq 0x18(%rax), %rdi
movl 0x5c(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x18900
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::getNodeWithOneUncommonNeighbor(std::vector<unsigned int, std::allocator<unsigned int>> const&, unsigned int&) const
uint32_t Graph::getNodeWithOneUncommonNeighbor(const vector<uint32_t> &neighbors, uint32_t &uncommonNeighbor) const {
    uncommonNeighbor = NONE;
    for (uint32_t pos = 0 ; pos < nodeIndex.size() ; pos++) {
        if (!nodeIndex[pos].removed && nodeIndex[pos].edges == 3 || nodeIndex[pos].edges == 4) { // Optimization for 3-4 structures reduction
            uint32_t node = (!mapping ? pos : posToId->at(pos));
            vector<uint32_t> newNeighbors;
            gatherNeighbors(node, newNeighbors);
            if (setsHaveKUncommonElements(neighbors, newNeighbors, 1, uncommonNeighbor)) {
                return node;
            }
        }
    }
    return NONE;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x68(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0x0, 0x64(%rsp)
movq 0x20(%rsp), %rdi
movl 0x64(%rsp), %eax
movq %rax, 0x18(%rsp)
callq 0x18830
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x4f5c
movq 0x20(%rsp), %rdi
movl 0x64(%rsp), %eax
movl %eax, %esi
callq 0x18850
testb $0x1, 0x8(%rax)
jne 0x4e43
movq 0x20(%rsp), %rdi
movl 0x64(%rsp), %eax
movl %eax, %esi
callq 0x18850
cmpl $0x3, 0x4(%rax)
je 0x4e5d
movq 0x20(%rsp), %rdi
movl 0x64(%rsp), %eax
movl %eax, %esi
callq 0x18850
cmpl $0x4, 0x4(%rax)
jne 0x4f4a
movq 0x20(%rsp), %rax
testb $0x1, 0x3c(%rax)
jne 0x4e72
movl 0x64(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x4e8c
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rdi
movl 0x64(%rsp), %eax
movl %eax, %esi
callq 0x18870
movl (%rax), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x60(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x17e60
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %ecx
leaq 0x60(%rsp), %rsi
leaq 0x44(%rsp), %r8
callq 0x19c30
jmp 0x4eca
movq 0x70(%rsp), %rdi
movl $0x1, 0x30(%rsp)
movq 0x68(%rsp), %rcx
leaq 0x48(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x452e0
movb %al, 0x7(%rsp)
jmp 0x4ef1
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x4efb
jmp 0x4f2a
movl 0x60(%rsp), %eax
movl %eax, 0x84(%rsp)
movl $0x1, 0x2c(%rsp)
jmp 0x4f32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x18520
jmp 0x4f76
movl $0x0, 0x2c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x18520
movl 0x2c(%rsp), %eax
testl %eax, %eax
je 0x4f48
jmp 0x4f46
jmp 0x4f67
jmp 0x4f4a
jmp 0x4f4c
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x4df3
movl $0xffffffff, 0x84(%rsp) # imm = 0xFFFFFFFF
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x2310
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::getExtendedGrandchildren(Graph::GraphTraversal&, std::unordered_set<unsigned int, std::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<unsigned int>>&, bool*, bool const&) const
void Graph::getExtendedGrandchildren(Graph::GraphTraversal &graphTraversal, unordered_set<uint32_t> &extendedGrandchildren, bool *isUnconfined, const bool &stopAtFirst) const {
    while (graphTraversal.curEdgeOffset != NONE) {
        uint32_t neighbor = (*edgeBuffer)[graphTraversal.curEdgeOffset];
        uint32_t outerNeighbor;
        bool exactlyOne;
        getOuterNeighbor(graphTraversal.curNode, neighbor, outerNeighbor, exactlyOne);
        if (isUnconfined != NULL && outerNeighbor == NONE) {
            *isUnconfined = true;
            break;
        } else if (exactlyOne) {
            extendedGrandchildren.insert(outerNeighbor);
            if (stopAtFirst) {
                return;
            }
        }
        getNextEdge(graphTraversal);
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
cmpl $-0x1, 0x4(%rax)
je 0x504e
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x48(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, %esi
callq 0x18900
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x48(%rsp), %rsi
leaq 0x2c(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x27(%rsp), %r8
callq 0x19f40
cmpq $0x0, 0x38(%rsp)
je 0x500b
cmpl $-0x1, 0x28(%rsp)
jne 0x500b
movq 0x38(%rsp), %rax
movb $0x1, (%rax)
jmp 0x504e
testb $0x1, 0x27(%rsp)
je 0x5038
movq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x18960
movq %rax, 0x10(%rsp)
movb %dl, 0x18(%rsp)
movq 0x30(%rsp), %rax
testb $0x1, (%rax)
je 0x5036
jmp 0x504e
jmp 0x5038
jmp 0x503a
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x19560
jmp 0x4fa7
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::getOptimalNodeTheta3(unsigned int, unsigned int const&) const
uint32_t Graph::getOptimalNodeTheta3(const uint32_t initialMaxDegreeNode, const uint32_t &initialMaxDegree) const {
    uint32_t maxDegree = initialMaxDegree;
    uint32_t maxDegreeNode = initialMaxDegreeNode;
    if (maxDegree >= 4) {
        uint32_t maxNeighborsAtDistance2 = 0;
        GraphTraversal graphTraversal(*this, maxDegreeNode);
        while (graphTraversal.curNode != NONE) {
            unordered_set<uint32_t> neighborsAtDistance2;
            getNeighborsAtDistance2(graphTraversal.curNode, neighborsAtDistance2);
            if (neighborsAtDistance2.size() > maxNeighborsAtDistance2) {
                maxDegreeNode = graphTraversal.curNode;
                maxNeighborsAtDistance2 = neighborsAtDistance2.size();
            }
            getNextNode(graphTraversal);
        }
    }
    return maxDegreeNode;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movl %esi, 0x8c(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x80(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x7c(%rsp)
movl 0x8c(%rsp), %eax
movl %eax, 0x78(%rsp)
cmpl $0x4, 0x7c(%rsp)
jb 0x5174
movq 0x10(%rsp), %rsi
movl $0x0, 0x74(%rsp)
leaq 0x6c(%rsp), %rdi
leaq 0x78(%rsp), %rdx
callq 0x2a70
cmpl $-0x1, 0x6c(%rsp)
je 0x5172
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1a020
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0xffffffff, 0x2c(%rsp) # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %r8d
leaq 0x6c(%rsp), %rsi
leaq 0x2c(%rsp), %rcx
callq 0x2f30
jmp 0x510d
leaq 0x30(%rsp), %rdi
callq 0x191e0
movl 0x74(%rsp), %ecx
cmpq %rcx, %rax
jbe 0x5152
movl 0x6c(%rsp), %eax
movl %eax, 0x78(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x191e0
movl %eax, 0x74(%rsp)
jmp 0x5152
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1a030
jmp 0x5180
movq 0x10(%rsp), %rdi
leaq 0x6c(%rsp), %rsi
callq 0x185f0
jmp 0x5163
leaq 0x30(%rsp), %rdi
callq 0x1a030
jmp 0x50cb
jmp 0x5174
movl 0x78(%rsp), %eax
addq $0x98, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x2310
nopw (%rax,%rax)
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::getOptimalDegree4Node() const
uint32_t Graph::getOptimalDegree4Node() const {
    uint32_t node = getOptimalDegree4Node1();
    if (node == NONE) {
        node = getOptimalDegree4Node2();
        if (node == NONE) {
            uint32_t maxNodeWithCond = NONE;
            uint32_t maxNode = NONE;
            getOptimalDegree4Node3(maxNodeWithCond, maxNode);
            if (maxNodeWithCond != NONE) {
                node = maxNodeWithCond;
            } else {
                node = maxNode;
            }
        }
    }
    //cout << "branching on optimal degree 4 node " << node << "\n";
    return node;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5220
movl %eax, 0x1c(%rsp)
cmpl $-0x1, 0x1c(%rsp)
jne 0x5209
movq 0x8(%rsp), %rdi
callq 0x5550
movl %eax, 0x1c(%rsp)
cmpl $-0x1, 0x1c(%rsp)
jne 0x5207
movq 0x8(%rsp), %rdi
movl $0xffffffff, 0x18(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
leaq 0x18(%rsp), %rsi
leaq 0x14(%rsp), %rdx
callq 0x5820
cmpl $-0x1, 0x18(%rsp)
je 0x51fd
movl 0x18(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x5205
movl 0x14(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x5207
jmp 0x5209
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::getEffectiveNodeMeasure(unsigned int const&) const
uint32_t Graph::getEffectiveNodeMeasure(const uint32_t &bound) const {
    uint32_t measure = 0;
    GraphTraversal graphTraversal(*this);
    while (graphTraversal.curNode != NONE) {
        uint32_t degree = getNodeDegree(graphTraversal.curNode);
        if (degree > 2) {
            measure += (degree - 2);
        }
        if (bound != NONE && measure > bound) {
            break;
        }
        getNextNode(graphTraversal);
    }
    return measure;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rsi
movq %rsi, (%rsp)
movl $0x0, 0x14(%rsp)
leaq 0xc(%rsp), %rdi
callq 0x2a40
cmpl $-0x1, 0xc(%rsp)
je 0x6ac1
movq (%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x1a040
movl %eax, 0x8(%rsp)
cmpl $0x2, 0x8(%rsp)
jbe 0x6a98
movl 0x8(%rsp), %eax
subl $0x2, %eax
addl 0x14(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
cmpl $-0x1, (%rax)
je 0x6ab1
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jbe 0x6ab1
jmp 0x6ac1
movq (%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x185f0
jmp 0x6a69
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::isInTriangle(unsigned int const&) const
bool Graph::isInTriangle(const uint32_t &node) const {
    vector<uint32_t> neighbors;
    for (uint32_t i = 0 ; i < neighbors.size() ; i++) {
        for (uint32_t j = i+1 ; j < neighbors.size() ; j++) {
            if (edgeExists(neighbors[i], neighbors[j])) {
                return true;
            }
        }
    }
    return false;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x17e60
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
movq %rax, 0x20(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x188e0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x7cd4
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
movl 0x40(%rsp), %eax
movq %rax, 0x18(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x188e0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x7cc2
movl 0x44(%rsp), %eax
movl %eax, %esi
leaq 0x48(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x18900
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
movl 0x40(%rsp), %eax
movl %eax, %esi
callq 0x18900
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x18920
movb %al, 0x17(%rsp)
jmp 0x7c7d
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x7c87
jmp 0x7cb0
movb $0x1, 0x77(%rsp)
movl $0x1, 0x30(%rsp)
jmp 0x7ce1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x18520
jmp 0x7cf6
jmp 0x7cb2
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x7c19
jmp 0x7cc4
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x7bea
movb $0x0, 0x77(%rsp)
movl $0x1, 0x30(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x18520
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x2310
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::isFineInstance() const
bool Graph::isFineInstance() const {
    GraphTraversal graphTraversal(*this);
    bool fineInstance = false;
    while (graphTraversal.curNode != NONE) {
        uint32_t degree = getNodeDegree(graphTraversal.curNode);
        if (degree >= 4) {
            fineInstance = true;
        } else if (degree == 1) {
            return false;
        }
        getNextNode(graphTraversal);
    }
    return fineInstance;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rsi
movq %rsi, (%rsp)
leaq 0x10(%rsp), %rdi
callq 0x2a40
movb $0x0, 0xf(%rsp)
cmpl $-0x1, 0x10(%rsp)
je 0x7d68
movq (%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1a040
movl %eax, 0x8(%rsp)
cmpl $0x4, 0x8(%rsp)
jb 0x7d48
movb $0x1, 0xf(%rsp)
jmp 0x7d58
cmpl $0x1, 0x8(%rsp)
jne 0x7d56
movb $0x0, 0x27(%rsp)
jmp 0x7d72
jmp 0x7d58
movq (%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x185f0
jmp 0x7d21
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::collectZeroDegreeNodes()
void Graph::collectZeroDegreeNodes() {
    for (uint32_t pos = 0 ; pos < nodeIndex.size() ; pos++) {
        if (!nodeIndex[pos].removed && !nodeIndex[pos].edges) {
            zeroDegreeNodes.push_back((!mapping ? pos : posToId->at(pos)));
            nodeIndex[pos].removed = true;
        }
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %eax
movq %rax, 0x18(%rsp)
callq 0x18830
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x9eec
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x19050
testb $0x1, 0x8(%rax)
jne 0x9eda
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x19050
cmpl $0x0, 0x4(%rax)
jne 0x9eda
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x20, %rcx
movq %rcx, 0x10(%rsp)
testb $0x1, 0x3c(%rax)
jne 0x9e9e
leaq 0x2c(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x9eb7
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x18870
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x19070
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x19050
movb $0x1, 0x8(%rax)
jmp 0x9edc
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x9e2b
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::getNodeCountWithEdges() const
uint32_t Graph::getNodeCountWithEdges() const {
    uint32_t count = 0;
    for (auto &node: nodeIndex) {
        if (!node.removed && node.edges) {
            count++;
        }
    }
    return count;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movl $0x0, 0x2c(%rsp)
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1b6b0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1b6e0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1b710
testb $0x1, %al
jne 0xb29e
jmp 0xb2dc
leaq 0x18(%rsp), %rdi
callq 0x1b750
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
testb $0x1, 0x8(%rax)
jne 0xb2ce
movq 0x8(%rsp), %rax
cmpl $0x0, 0x4(%rax)
je 0xb2ce
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xb2d0
leaq 0x18(%rsp), %rdi
callq 0x1b760
jmp 0xb289
movl 0x2c(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::addPalmTreeArc(std::unordered_map<unsigned int, std::vector<unsigned int, std::allocator<unsigned int>>, std::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, std::vector<unsigned int, std::allocator<unsigned int>>>>>&, unsigned int const&, unsigned int const&)
void Graph::addPalmTreeArc(unordered_map<uint32_t, vector<uint32_t> > &palmTree, const uint32_t &node, const uint32_t &neighbor) {
    auto res = palmTree.find(node);
    if (res == palmTree.end()) {
        vector<uint32_t> tmp;
        tmp.push_back(neighbor);
        palmTree.insert({node, tmp});
    } else {
        res->second.push_back(neighbor);
    }
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0x1af10
movq %rax, 0x88(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x1af60
movq %rax, 0x80(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x1af40
testb $0x1, %al
jne 0xb37f
jmp 0xb43e
leaq 0x68(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x17e60
movq 0x20(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0x19070
jmp 0xb3a2
movq 0xa0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x98(%rsp), %rsi
leaq 0x38(%rsp), %rdi
leaq 0x68(%rsp), %rdx
callq 0x1afe0
jmp 0xb3c8
movq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x1af90
movb %dl, 0xf(%rsp)
movq %rax, 0x10(%rsp)
jmp 0xb3e2
movb 0xf(%rsp), %al
movq 0x10(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movb %al, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x1b020
leaq 0x68(%rsp), %rdi
callq 0x18520
jmp 0xb45f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xb432
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x1b020
leaq 0x68(%rsp), %rdi
callq 0x18520
jmp 0xb467
leaq 0x88(%rsp), %rdi
callq 0x1b040
movq %rax, %rdi
addq $0x8, %rdi
movq 0x90(%rsp), %rsi
callq 0x19070
addq $0xa8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x2310
nopw %cs:(%rax,%rax)
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::printWithGraphTraversal(bool) const
void Graph::printWithGraphTraversal(bool direction) const {
    GraphTraversal graphTraversal(*this);
    while (graphTraversal.curNode != NONE) {
        while (graphTraversal.curEdgeOffset != NONE) {
            if (direction || !direction && graphTraversal.curNode < (*edgeBuffer)[graphTraversal.curEdgeOffset]) {
                cout << graphTraversal.curNode << "\t" << (*edgeBuffer)[graphTraversal.curEdgeOffset] << "\n";
            }
            getNextEdge(graphTraversal);
        }
        getNextNode(graphTraversal);
    }
    cout << "Zero degree nodes: \n";
    for (uint32_t i = 0 ; i < zeroDegreeNodes.size() ; i++) {
        cout << zeroDegreeNodes[i] << "\n";
    }
}

// Assembly:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x30(%rsp), %rsi
movq %rsi, 0x18(%rsp)
leaq 0x24(%rsp), %rdi
callq 0x2a40
cmpl $-0x1, 0x24(%rsp)
je 0xefe1
jmp 0xef23
cmpl $-0x1, 0x28(%rsp)
je 0xefcd
testb $0x1, 0x2f(%rsp)
jne 0xef63
testb $0x1, 0x2f(%rsp)
jne 0xefb9
movq 0x18(%rsp), %rax
movl 0x24(%rsp), %ecx
movl %ecx, 0x14(%rsp)
movq 0x18(%rax), %rdi
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0x18900
movq %rax, %rcx
movl 0x14(%rsp), %eax
cmpl (%rcx), %eax
jae 0xefb9
movl 0x24(%rsp), %esi
movq 0x4f062(%rip), %rdi     # 0x5dfd0
callq 0x2230
movq %rax, %rdi
leaq 0x37622(%rip), %rsi     # 0x4659f
callq 0x2190
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x18(%rax), %rdi
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0x18900
movq 0x8(%rsp), %rdi
movl (%rax), %esi
callq 0x2230
movq %rax, %rdi
leaq 0x37600(%rip), %rsi     # 0x465b4
callq 0x2190
movq 0x18(%rsp), %rdi
leaq 0x24(%rsp), %rsi
callq 0x19560
jmp 0xef23
movq 0x18(%rsp), %rdi
leaq 0x24(%rsp), %rsi
callq 0x185f0
jmp 0xef16
movq 0x4efe8(%rip), %rdi     # 0x5dfd0
leaq 0x375b2(%rip), %rsi     # 0x465a1
callq 0x2190
movl $0x0, 0x20(%rsp)
movq 0x18(%rsp), %rdi
movl 0x20(%rsp), %eax
movq %rax, (%rsp)
addq $0x20, %rdi
callq 0x188e0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0xf05c
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
movl 0x20(%rsp), %eax
movl %eax, %esi
callq 0x1b780
movl (%rax), %esi
movq 0x4ef95(%rip), %rdi     # 0x5dfd0
callq 0x2230
movq %rax, %rdi
leaq 0x3756a(%rip), %rsi     # 0x465b4
callq 0x2190
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0xeffc
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::printEdgeCounts() const
void Graph::printEdgeCounts() const {
    for (uint32_t pos = 0 ; pos < nodeIndex.size() ; pos++) {
        if (nodeIndex[pos].removed) {
            continue;
        }
        uint32_t node = (!mapping ? pos : (*posToId)[pos]);
        cout << "Node " << node << " has " << nodeIndex[pos].edges << " edges\n";
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %eax
movq %rax, 0x18(%rsp)
callq 0x18830
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0xf170
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x18850
testb $0x1, 0x8(%rax)
je 0xf0ca
jmp 0xf160
movq 0x20(%rsp), %rax
testb $0x1, 0x3c(%rax)
jne 0xf0df
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0xf0f9
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x18900
movl (%rax), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x28(%rsp)
movq 0x4eec8(%rip), %rdi     # 0x5dfd0
leaq 0x37ffc(%rip), %rsi     # 0x4710b
callq 0x2190
movq %rax, %rdi
movl 0x28(%rsp), %esi
callq 0x2230
movq %rax, %rdi
leaq 0x3748c(%rip), %rsi     # 0x465b6
callq 0x2190
movq 0x20(%rsp), %rdi
movq %rax, 0x8(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x18850
movq 0x8(%rsp), %rdi
movl 0x4(%rax), %esi
callq 0x2230
movq %rax, %rdi
leaq 0x37461(%rip), %rsi     # 0x465bc
callq 0x2190
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xf08b
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::parseNodeIDs(char*, unsigned int*, unsigned int*)
void Graph::parseNodeIDs(char *buf, uint32_t *sourceNode, uint32_t *targetNode) {
    uint32_t *node = sourceNode;
    for (int i = 0 ; i < 2 ; i++) {
        uint32_t id = 0;
        for (; *buf != ' ' && *buf != '\t' && *buf != '\n' && *buf != '\0' ; buf++) {
            id = id * 10 + (*buf - '0');
        }
        *node = id;
        node = targetNode;
        for (; *buf == ' ' || *buf == '\t' ; buf++);
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
cmpl $0x2, -0x24(%rsp)
jge 0xff27
movl $0x0, -0x28(%rsp)
movq -0x8(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x20, %ecx
movb %al, -0x29(%rsp)
je 0xfe8f
movq -0x8(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x9, %ecx
movb %al, -0x29(%rsp)
je 0xfe8f
movq -0x8(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x29(%rsp)
je 0xfe8f
movq -0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rsp)
movb -0x29(%rsp), %al
testb $0x1, %al
jne 0xfe99
jmp 0xfebf
imull $0xa, -0x28(%rsp), %eax
movq -0x8(%rsp), %rcx
movsbl (%rcx), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, -0x28(%rsp)
movq -0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
jmp 0xfe44
movl -0x28(%rsp), %ecx
movq -0x20(%rsp), %rax
movl %ecx, (%rax)
movq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x8(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x2a(%rsp)
je 0xfef9
movq -0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x2a(%rsp)
movb -0x2a(%rsp), %al
testb $0x1, %al
jne 0xff03
jmp 0xff15
jmp 0xff05
movq -0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
jmp 0xfed4
jmp 0xff17
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0xfe31
retq
nopl (%rax,%rax)
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.cpp
// Function: Graph::fill(unsigned int const&, bool const&)
void Graph::fill(const uint32_t &size, const bool &checkIndependentSet) {
    //cout << "start missing nodes from " << nodeIndex.size() << " to " << size << endl;
    while (nodeIndex.size() < size) {
        nodeIndex.push_back(NodeInfo(edgeBuffer->size(), 0));
        if (!checkIndependentSet) {
            zeroDegreeNodes.push_back(nodeIndex.size()-1);
            nodeIndex[nodeIndex.size()-1].removed = true;
        }
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x18830
movq 0x38(%rsp), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0xffff
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x188e0
movl %eax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
leaq 0x24(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x1c(%rsp), %rdx
callq 0x19190
movq 0x10(%rsp), %rdi
leaq 0x24(%rsp), %rsi
callq 0x19160
movq 0x30(%rsp), %rax
testb $0x1, (%rax)
jne 0xfffa
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0x20, %rax
movq %rax, 0x8(%rsp)
callq 0x18830
movq 0x8(%rsp), %rdi
subq $0x1, %rax
movl %eax, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x1b870
movq 0x10(%rsp), %rdi
callq 0x18830
movq 0x10(%rsp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x19050
movb $0x1, 0x8(%rax)
jmp 0xff4d
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.hpp
// Function: Graph::getOuterNeighbor(unsigned int const&, unsigned int const&, unsigned int&, bool&) const
void getOuterNeighbor(const uint32_t &node, const uint32_t &neighbor, uint32_t &outerNeighbor, bool &exactlyOne) const {
        outerNeighbor = NONE;
        exactlyOne = false;
        bool found = false;
        GraphTraversal graphTraversal(*this, neighbor);
        while (graphTraversal.curEdgeOffset != NONE) {
            uint32_t extendedGrandchild = (*edgeBuffer)[graphTraversal.curEdgeOffset];
            if (extendedGrandchild != node && !edgeExists(extendedGrandchild, node)) {
                if (!found) {
                    found = true;
                    outerNeighbor = extendedGrandchild;
                } else {
                    return;
                }
            }
            getNextEdge(graphTraversal);
        }
        if (found) {
            exactlyOne = true;
        }
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x40(%rsp), %rsi
movq %rsi, 0x8(%rsp)
movq 0x28(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq 0x20(%rsp), %rax
movb $0x0, (%rax)
movb $0x0, 0x1f(%rsp)
movq 0x30(%rsp), %rdx
leaq 0x14(%rsp), %rdi
callq 0x2a70
cmpl $-0x1, 0x18(%rsp)
je 0x1a002
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x18900
movl (%rax), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq 0x38(%rsp), %rcx
cmpl (%rcx), %eax
je 0x19ff1
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rdx
leaq 0x10(%rsp), %rsi
callq 0x18920
testb $0x1, %al
jne 0x19ff1
testb $0x1, 0x1f(%rsp)
jne 0x19fed
movb $0x1, 0x1f(%rsp)
movl 0x10(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
jmp 0x19fef
jmp 0x1a011
jmp 0x19ff1
movq 0x8(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x19560
jmp 0x19f8e
testb $0x1, 0x1f(%rsp)
je 0x1a011
movq 0x20(%rsp), %rax
movb $0x1, (%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.hpp
// Function: Graph::Traversal::Traversal(unsigned int const&, Graph const&, Graph::Traversal*)
Traversal(const uint32_t &node, const Graph &graph, Traversal *previous = NULL) {
            sourceNode = node;
            if (previous != NULL) {
                auto it = previous->set.begin();
                std::advance(it, previous->index);
                while (++it != previous->set.end()) {
                    set.insert(*it);
                }
                set.erase(node);
            }
            graph.gatherNeighbors(node, set);
            if (!set.size()) {
                index = NONE;
            } else {
                index = 0;
            }
        }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x193a0
movq 0x18(%rsp), %rax
movq 0x68(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x34(%rax)
cmpq $0x0, 0x58(%rsp)
je 0x1a7fd
movq 0x58(%rsp), %rdi
callq 0x197f0
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rax
movl 0x30(%rax), %esi
leaq 0x50(%rsp), %rdi
callq 0x1a620
jmp 0x1a765
jmp 0x1a767
leaq 0x50(%rsp), %rdi
callq 0x1d6c0
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
callq 0x19820
movq 0x10(%rsp), %rdi
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rsi
callq 0x1d6a0
testb $0x1, %al
jne 0x1a79a
jmp 0x1a7ea
leaq 0x50(%rsp), %rdi
callq 0x1a670
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x19500
movb %dl, 0x7(%rsp)
movq %rax, 0x8(%rsp)
jmp 0x1a7bc
movb 0x7(%rsp), %al
movq 0x8(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movb %al, 0x30(%rsp)
jmp 0x1a767
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x19880
jmp 0x1a853
movq 0x18(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x1d6f0
jmp 0x1a7fb
jmp 0x1a7fd
movq 0x18(%rsp), %rdx
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %ecx
leaq 0x24(%rsp), %r8
callq 0x1d720
jmp 0x1a824
movq 0x18(%rsp), %rdi
callq 0x19770
cmpq $0x0, %rax
jne 0x1a842
movq 0x18(%rsp), %rax
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
jmp 0x1a84e
movq 0x18(%rsp), %rax
movl $0x0, 0x30(%rax)
addq $0x78, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x2310
nopl (%rax)
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.hpp
// Function: Graph::advance(std::vector<Graph::Traversal*, std::allocator<Graph::Traversal*>>&, Graph::Traversal**, Graph const&, std::unordered_set<unsigned int, std::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<unsigned int>>&)
static bool advance(std::vector<Traversal *> &frontier, Traversal **traversal, const Graph &graph, std::unordered_set<uint32_t> &set) {
        bool validNeighbor = false;
        while(!validNeighbor) {
            *traversal = frontier.back();
            (*traversal)->next();
            if ((*traversal)->index != NONE) {
                validNeighbor = true;
            } else {
                set.erase((*traversal)->sourceNode);
                delete *traversal;
                frontier.pop_back();
                if (frontier.empty()) {
                    return false;
                }
            }
        }
        return true;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movb $0x0, 0xf(%rsp)
movb 0xf(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1a8ec
jmp 0x1a985
movq 0x28(%rsp), %rdi
callq 0x1ebd0
movq (%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x1ec10
movq 0x20(%rsp), %rax
movq (%rax), %rax
cmpl $-0x1, 0x30(%rax)
je 0x1a923
movb $0x1, 0xf(%rsp)
jmp 0x1a980
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
addq $0x34, %rsi
callq 0x1a890
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x1a95d
movq (%rsp), %rdi
callq 0x1a860
movq (%rsp), %rdi
callq 0x2180
movq 0x28(%rsp), %rdi
callq 0x1a870
movq 0x28(%rsp), %rdi
callq 0x1ec60
testb $0x1, %al
jne 0x1a977
jmp 0x1a97e
movb $0x0, 0x37(%rsp)
jmp 0x1a98a
jmp 0x1a980
jmp 0x1a8dd
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: iPapatsoris[P]Maximum-Independent-Set/src/Graph.hpp
// Function: Graph::getFirstValidNeighborOffset(unsigned int const&) const
uint32_t getFirstValidNeighborOffset(const uint32_t &pos) const {
        bool validNeighbor = false;
        uint32_t offset = nodeIndex[pos].offset;
        uint32_t nextNodeOffset = (pos == nodeIndex.size()-1 ? edgeBuffer->size() : nodeIndex[pos+1].offset);
        for ( ; offset < nextNodeOffset ; offset++) {
            uint32_t nPos = (!mapping ? (*edgeBuffer)[offset] : idToPos->at((*edgeBuffer)[offset]));
            if (!nodeIndex[nPos].removed) {
                validNeighbor = true;
                break;
            }
        }
        return (validNeighbor ? offset : NONE);
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movb $0x0, 0x47(%rsp)
movq 0x48(%rsp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x18850
movq 0x28(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x40(%rsp)
movq 0x48(%rsp), %rax
movl (%rax), %eax
movq %rax, 0x30(%rsp)
callq 0x18830
movq %rax, %rcx
movq 0x30(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x1cabd
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x188e0
movq %rax, 0x20(%rsp)
jmp 0x1cadc
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rax
movl (%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x18850
movl (%rax), %eax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl %eax, 0x3c(%rsp)
movl 0x40(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jae 0x1cb81
movq 0x28(%rsp), %rax
testb $0x1, 0x3c(%rax)
jne 0x1cb1a
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x40(%rsp), %eax
movl %eax, %esi
callq 0x18900
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
jmp 0x1cb4a
movq 0x28(%rsp), %rax
movq 0x40(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rdi
movl 0x40(%rsp), %eax
movl %eax, %esi
callq 0x18900
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x188b0
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x38(%rsp)
movl 0x38(%rsp), %eax
movl %eax, %esi
callq 0x18850
testb $0x1, 0x8(%rax)
jne 0x1cb6f
movb $0x1, 0x47(%rsp)
jmp 0x1cb81
jmp 0x1cb71
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x1cae5
testb $0x1, 0x47(%rsp)
je 0x1cb92
movl 0x40(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x1cb9d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0xc(%rsp)
jmp 0x1cb9d
movl 0xc(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iPapatsoris[P]Maximum-Independent-Set/src/Reductions.cpp
// Function: Reductions::run(unsigned int const&)
void Reductions::run(const uint32_t &theta) {
    if (!graph.nodeIndex.size()) {
        return;
    }
    switch(theta) {
        case 8:
        case 7:
        case 6:
            reduce6(theta);
            break;
        case 5:
            reduce5(theta);
            break;
        case 4:
            reduce4(theta);
            break;
        case 3:
            reduce3(theta);
            break;
        default:
            assert(false);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq (%rax), %rdi
callq 0x18830
cmpq $0x0, %rax
jne 0x2e51b
jmp 0x2e5a9
movq 0x18(%rsp), %rax
movl (%rax), %eax
addl $-0x3, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x5, %eax
ja 0x2e58a
movq 0x8(%rsp), %rax
leaq 0x183bf(%rip), %rcx     # 0x468fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2e5b0
jmp 0x2e5a9
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2e6e0
jmp 0x2e5a9
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2e830
jmp 0x2e5a9
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2e9c0
jmp 0x2e5a9
leaq 0x17bf5(%rip), %rdi     # 0x46186
leaq 0x1837c(%rip), %rsi     # 0x46914
movl $0x21, %edx
leaq 0x18383(%rip), %rcx     # 0x46927
callq 0x2110
addq $0x28, %rsp
retq
nop
// File: iPapatsoris[P]Maximum-Independent-Set/src/Reductions.cpp
// Function: Reductions::reduce6(unsigned int const&)
void Reductions::reduce6(const uint32_t &theta) {
    bool firstTime = true;
    unordered_set<uint32_t> *oldCandidateNodes = new unordered_set<uint32_t>();
    unordered_set<uint32_t> *newCandidateNodes = new unordered_set<uint32_t>();
    do {
        removeUnconfinedNodes();
    } while (foldCompleteKIndependentSets(theta, &oldCandidateNodes, &newCandidateNodes));
    delete oldCandidateNodes;
    delete newCandidateNodes;
    buildCC();
    removeLineGraphs(theta);
    graph.rebuild(reduceInfo);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x1, 0x47(%rsp)
movl $0x38, %edi
callq 0x21b0
movq %rax, %rdi
movq %rdi, 0x18(%rsp)
xorl %esi, %esi
movl $0x38, %edx
callq 0x20e0
movq 0x18(%rsp), %rdi
callq 0x1a020
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x38, %edi
callq 0x21b0
movq %rax, %rdi
movq %rdi, 0x20(%rsp)
xorl %esi, %esi
movl $0x38, %edx
callq 0x20e0
movq 0x20(%rsp), %rdi
callq 0x1a020
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2eb70
movq 0x10(%rsp), %rdi
movq 0x48(%rsp), %rsi
movb $0x0, 0x2f(%rsp)
leaq 0x38(%rsp), %rdx
leaq 0x30(%rsp), %rcx
leaq 0x2f(%rsp), %r8
callq 0x2ebe0
testb $0x1, %al
jne 0x2e631
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2e686
movq 0x8(%rsp), %rdi
callq 0x1a030
movq 0x8(%rsp), %rdi
callq 0x2180
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x2e6a7
movq (%rsp), %rdi
callq 0x1a030
movq (%rsp), %rdi
callq 0x2180
movq 0x10(%rsp), %rdi
callq 0x2ece0
movq 0x10(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x2f190
movq 0x10(%rsp), %rsi
movq (%rsi), %rdi
addq $0x10, %rsi
callq 0x33d0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iPapatsoris[P]Maximum-Independent-Set/src/Reductions.cpp
// Function: Reductions::reduce5(unsigned int const&)
void Reductions::reduce5(const uint32_t &theta) {
    unordered_set<uint32_t> *oldCandidateNodes = new unordered_set<uint32_t>();
    unordered_set<uint32_t> *newCandidateNodes = new unordered_set<uint32_t>();
    do {
        do {
            removeUnconfinedNodes();
        } while (foldCompleteKIndependentSets(theta, &oldCandidateNodes, &newCandidateNodes));
    } while (removeShortFunnels(theta));
    delete oldCandidateNodes;
    delete newCandidateNodes;
    buildCC();
    removeEasyInstances(theta);
    removeLineGraphs(theta);
    graph.rebuild(reduceInfo);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x38, %edi
callq 0x21b0
movq %rax, %rdi
movq %rdi, 0x20(%rsp)
xorl %esi, %esi
movl $0x38, %edx
callq 0x20e0
movq 0x20(%rsp), %rdi
callq 0x1a020
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movl $0x38, %edi
callq 0x21b0
movq %rax, %rdi
movq %rdi, 0x28(%rsp)
xorl %esi, %esi
movl $0x38, %edx
callq 0x20e0
movq 0x28(%rsp), %rdi
callq 0x1a020
movq 0x28(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0x2e75e
movq 0x18(%rsp), %rdi
callq 0x2eb70
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
movb $0x0, 0x37(%rsp)
leaq 0x40(%rsp), %rdx
leaq 0x38(%rsp), %rcx
leaq 0x37(%rsp), %r8
callq 0x2ebe0
testb $0x1, %al
jne 0x2e75e
jmp 0x2e791
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x2f7b0
testb $0x1, %al
jne 0x2e75c
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x2e7c8
movq 0x10(%rsp), %rdi
callq 0x1a030
movq 0x10(%rsp), %rdi
callq 0x2180
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2e7ec
movq 0x8(%rsp), %rdi
callq 0x1a030
movq 0x8(%rsp), %rdi
callq 0x2180
movq 0x18(%rsp), %rdi
callq 0x2ece0
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x30580
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x2f190
movq 0x18(%rsp), %rsi
movq (%rsi), %rdi
addq $0x10, %rsi
callq 0x33d0
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: iPapatsoris[P]Maximum-Independent-Set/src/Reductions.cpp
// Function: Reductions::reduce4(unsigned int const&)
void Reductions::reduce4(const uint32_t &theta) {
    unordered_set<uint32_t> *oldCandidateNodes = new unordered_set<uint32_t>();
    unordered_set<uint32_t> *newCandidateNodes = new unordered_set<uint32_t>();
    do {
        do {
            do {
                do {
                    foldCompleteKIndependentSets(theta, &oldCandidateNodes, &newCandidateNodes);
                } while (removeDominatedNodes(theta));
            } while (removeUnconfinedNodes());
        } while (foldCompleteKIndependentSets(theta, &oldCandidateNodes, &newCandidateNodes, true));
    } while (removeShortFunnels(theta));
    delete oldCandidateNodes;
    delete newCandidateNodes;
    buildCC();
    removeEasyInstances(theta);
    removeLineGraphs(theta);
    graph.rebuild(reduceInfo);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x38, %edi
callq 0x21b0
movq %rax, %rdi
movq %rdi, 0x20(%rsp)
xorl %esi, %esi
movl $0x38, %edx
callq 0x20e0
movq 0x20(%rsp), %rdi
callq 0x1a020
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movl $0x38, %edi
callq 0x21b0
movq %rax, %rdi
movq %rdi, 0x28(%rsp)
xorl %esi, %esi
movl $0x38, %edx
callq 0x20e0
movq 0x28(%rsp), %rdi
callq 0x1a020
movq 0x28(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0x2e8ae
jmp 0x2e8b0
jmp 0x2e8b2
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
movb $0x0, 0x37(%rsp)
leaq 0x40(%rsp), %rdx
leaq 0x38(%rsp), %rcx
leaq 0x37(%rsp), %r8
callq 0x2ebe0
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x307f0
testb $0x1, %al
jne 0x2e8b2
jmp 0x2e8ea
movq 0x18(%rsp), %rdi
callq 0x2eb70
testb $0x1, %al
jne 0x2e8b0
jmp 0x2e8fa
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
movb $0x1, 0x36(%rsp)
leaq 0x40(%rsp), %rdx
leaq 0x38(%rsp), %rcx
leaq 0x36(%rsp), %r8
callq 0x2ebe0
testb $0x1, %al
jne 0x2e8ae
jmp 0x2e923
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x2f7b0
testb $0x1, %al
jne 0x2e8ac
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x2e95e
movq 0x10(%rsp), %rdi
callq 0x1a030
movq 0x10(%rsp), %rdi
callq 0x2180
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2e982
movq 0x8(%rsp), %rdi
callq 0x1a030
movq 0x8(%rsp), %rdi
callq 0x2180
movq 0x18(%rsp), %rdi
callq 0x2ece0
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x30580
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x2f190
movq 0x18(%rsp), %rsi
movq (%rsi), %rdi
addq $0x10, %rsi
callq 0x33d0
addq $0x58, %rsp
retq
// File: iPapatsoris[P]Maximum-Independent-Set/src/Reductions.cpp
// Function: Reductions::reduce3(unsigned int const&)
void Reductions::reduce3(const uint32_t &theta) {
    unordered_set<uint32_t> *oldCandidateNodes = new unordered_set<uint32_t>();
    unordered_set<uint32_t> *newCandidateNodes = new unordered_set<uint32_t>();
    do {
        do {
            do {
                do {
                    do {
                        removeDominatedNodes(theta);
                    } while (foldCompleteKIndependentSets(theta, &oldCandidateNodes, &newCandidateNodes));
                } while (removeUnconfinedNodes());
            } while (foldCompleteKIndependentSets(theta, &oldCandidateNodes, &newCandidateNodes, true));
        } while (removeShortFunnels(theta));
    } while (removeDesks());
    delete oldCandidateNodes;
    delete newCandidateNodes;
    buildCC();
    removeEasyInstances(theta);
    removeLineGraphs(theta);
    graph.rebuild(reduceInfo);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x38, %edi
callq 0x21b0
movq %rax, %rdi
movq %rdi, 0x20(%rsp)
xorl %esi, %esi
movl $0x38, %edx
callq 0x20e0
movq 0x20(%rsp), %rdi
callq 0x1a020
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movl $0x38, %edi
callq 0x21b0
movq %rax, %rdi
movq %rdi, 0x28(%rsp)
xorl %esi, %esi
movl $0x38, %edx
callq 0x20e0
movq 0x28(%rsp), %rdi
callq 0x1a020
movq 0x28(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0x2ea3e
jmp 0x2ea40
jmp 0x2ea42
jmp 0x2ea44
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x307f0
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
movb $0x0, 0x37(%rsp)
leaq 0x40(%rsp), %rdx
leaq 0x38(%rsp), %rcx
leaq 0x37(%rsp), %r8
callq 0x2ebe0
testb $0x1, %al
jne 0x2ea44
jmp 0x2ea7c
movq 0x18(%rsp), %rdi
callq 0x2eb70
testb $0x1, %al
jne 0x2ea42
jmp 0x2ea8c
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
movb $0x1, 0x36(%rsp)
leaq 0x40(%rsp), %rdx
leaq 0x38(%rsp), %rcx
leaq 0x36(%rsp), %r8
callq 0x2ebe0
testb $0x1, %al
jne 0x2ea40
jmp 0x2eab5
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x2f7b0
testb $0x1, %al
jne 0x2ea3e
jmp 0x2eace
movq 0x18(%rsp), %rdi
callq 0x30860
testb $0x1, %al
jne 0x2ea3c
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x2eb04
movq 0x10(%rsp), %rdi
callq 0x1a030
movq 0x10(%rsp), %rdi
callq 0x2180
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2eb28
movq 0x8(%rsp), %rdi
callq 0x1a030
movq 0x8(%rsp), %rdi
callq 0x2180
movq 0x18(%rsp), %rdi
callq 0x2ece0
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x30580
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x2f190
movq 0x18(%rsp), %rsi
movq (%rsi), %rdi
addq $0x10, %rsi
callq 0x33d0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iPapatsoris[P]Maximum-Independent-Set/src/Reductions.cpp
// Function: Reductions::removeUnconfinedNodes()
bool Reductions::removeUnconfinedNodes() {
    //cout << "\n**Performing unconfined nodes reduction**" << endl;
    ReduceInfo old = reduceInfo;
    removeUnconfinedNodes2();
    if (old.nodesRemoved == reduceInfo.nodesRemoved) {
        return false;
    }
    do {
        old = reduceInfo;
        removeUnconfinedNodes2();
    } while (old.nodesRemoved != reduceInfo.nodesRemoved);
    return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x10(%rdi), %eax
movl %eax, 0x14(%rsp)
callq 0x32900
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x10(%rcx), %eax
jne 0x2eba4
movb $0x0, 0x27(%rsp)
jmp 0x2ebca
jmp 0x2eba6
movq 0x8(%rsp), %rdi
movl 0x10(%rdi), %eax
movl %eax, 0x14(%rsp)
callq 0x32900
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x10(%rcx), %eax
jne 0x2eba6
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)